diff --git a/components/LinkButton/index.tsx b/components/LinkButton/index.tsx
new file mode 100644
index 0000000..48c1421
--- /dev/null
+++ b/components/LinkButton/index.tsx
@@ -0,0 +1,22 @@
+import { cn } from "@/utils/classnames";
+import Link from "next/link";
+import { type ReactNode } from "react";
+
+export interface LinkButtonProps {
+ href: string;
+ children: ReactNode;
+ id?: string;
+ className?: string;
+}
+
+// TODO
+export const LinkButton = ({
+ href,
+ children,
+ id,
+ className,
+}: LinkButtonProps) => (
+
+ {children}
+
+);
diff --git a/components/TwistyPlayer.tsx b/components/TwistyPlayer.tsx
index c535c8e..c9d454c 100644
--- a/components/TwistyPlayer.tsx
+++ b/components/TwistyPlayer.tsx
@@ -14,19 +14,44 @@ export interface TwistyPlayerExtendedConfig extends TwistyPlayerConfig {
className?: string;
rootClassName?: string;
onTwistyInit?: (twisty: TP) => void;
- stickeringSetup?: Alg | string;
+ rotateStickering?: Alg | string;
}
-/**
- * A React wrapper for the cubing.js `` element.
- */
+ /**
+ * A React wrapper for the cubing.js `` element.
+ * See all supported props: https://experiments.cubing.net/cubing.js/twisty/twisty-player-props/
+ * Please note: in React, these props are written in "camel case", for example controlPanel instead of control-panel.
+ * There are three additional props added for convenience:
+ * 1. `className`: CSS class to customize the Twisty Player itself
+ * 2. `rootClassName`: CSS class to customize the `` element that wraps the Twisty Player
+ * 3. `rotateStickering`: a cube rotation that translates the stickering
+ *
+ * See the end of the file for documentation about the `experimentalStickeringMaskOrbits` prop.
+ *
+ * @example
+ * import TwistyPlayer from "@site/src/components/TwistyPlayer";
+ * // Roux FB+SS with custom stickering.
+ * // The blocks have orange on bottom due to rotateStickering="z".
+ *
+ * // 5x5 with example cross scramble + solution.
+ * // Uses a preset stickering from cubing.js.
+ *
+ */
const TwistyPlayer = forwardRef(
(
{
className,
rootClassName,
onTwistyInit,
- stickeringSetup,
+ rotateStickering,
...props
}: TwistyPlayerExtendedConfig,
ref
@@ -35,13 +60,23 @@ const TwistyPlayer = forwardRef(
const spanRef = useRef(null);
useEffect(() => {
- const newTwisty = new TP(props);
+ // If `rotateStickering` is defined, prefix the alg setup with the inverse of `rotateStickering`.
+ const setupAlgOverride = rotateStickering
+ ? new Alg(rotateStickering)
+ .invert()
+ .concat(props.experimentalSetupAlg ?? [])
+ : undefined;
+ const newTwisty = new TP({
+ background: "none", // override default style
+ ...props,
+ ...(setupAlgOverride && { experimentalSetupAlg: setupAlgOverride }),
+ });
if (className) {
newTwisty.className = className;
}
- if (stickeringSetup) {
- transformTPMask(newTwisty, stickeringSetup)
+ if (rotateStickering) {
+ transformTPMask(newTwisty, rotateStickering)
}
newTwisty.style.maxWidth = "100%";
@@ -69,36 +104,59 @@ const TwistyPlayer = forwardRef(
export default TwistyPlayer;
/* Documentation for the experimentalStickeringMaskOrbits prop/attribute:
-This prop is used to customize the way pieces are highlighted on the cube,
-if it's beyond the default supported stickerings such as OCLL or EOCross.
-It's an experimental feature that is subject to change.
-
-Pass in a string in the format "EDGES:xxxxxxxxxxxx,CORNERS:xxxxxxxx,CENTERS:xxxxxx"
-where each "x" is one of the following characters:
-"-": regular
-"D": dim
-"I": ignored
-"X": invisible
-"O": ignore non-primary (ignore the non-primary stickers)
-"P": permute non-primary (dim the primary stickers, useful for PLL and other stickerings where just the permutation of pieces matters)
-"o": ignoriented (same as O, except the primary sticker is also dimmed)
-"?": orientation without permutation (useful for EO and CO on the entire cube! Primary stickers are replaced with turquoise)
-This is defined in https://github.com/cubing/cubing.js/blob/36c57c2dadc889b1321d05d8cfc005cef8a9bffd/src/cubing/twisty/model/props/puzzle/display/parseSerializedStickeringMask.ts
-
-"Primary stickers" are stickers that belong on the U and D faces, and FL, FR, BL, BR positions.
-They're relevant for edge orientation and corner orientation.
-
-Here is the order of the pieces for 3x3:
-EDGES:
- UF, UR, UB, UL,
- DF, DR, DB, DL,
- FR, FL, BR, BL
-
-CORNERS:
- UFR, UBR, UBL, UFL,
- DFR, DFL, DBL, DBR
-
-CENTERS: U, L, F, R, B, D
+ This prop is used to create custom stickerings for puzzles, letting you show/dim/hide specific pieces.
+ It's an experimental feature that is subject to change.
+
+ # ---------- 3x3 ----------
+
+ Set `experimentalStickeringMaskorbits` to a string in the format "EDGES:xxxxxxxxxxxx,CORNERS:xxxxxxxx,CENTERS:xxxxxx"
+ where each "x" is one of the following characters:
+ (table taken from https://github.com/cubing/cubing.js/commit/668179c8bb116b24775e5450a5d949c38068d3a0)
+ | Character | Primary | Other | Meaning |
+ |-----------|----------|--------|------------------------------------------------------|
+ | `-` | bright | bright | piece to solve |
+ | `D` | dim | dim | dim |
+ | `I` | gray | gray | ignored |
+ | `P` | bright | gray | to permute (e.g. PLL) |
+ | `O` | dim | bright | to orient (e.g. OLL) |
+ | `o` | dim | gray | oriented, primary sticker known (e.g. OLL completed) |
+ | `?` | oriented | gray | oriented, primary sticker unknown (e.g. EO) |
+ | `X` | N/A | N/A | invisible |
+
+ This is defined in https://github.com/cubing/cubing.js/blob/36c57c2dadc889b1321d05d8cfc005cef8a9bffd/src/cubing/twisty/model/props/puzzle/display/parseSerializedStickeringMask.ts
+
+ "Primary stickers" are stickers that belong on the U and D faces, and FL, FR, BL, BR positions.
+ They're relevant for edge orientation and corner orientation.
+
+ Here is the order of the pieces for 3x3:
+ EDGES:
+ UF, UR, UB, UL,
+ DF, DR, DB, DL,
+ FR, FL, BR, BL
+
+ CORNERS:
+ UFR, UBR, UBL, UFL,
+ DFR, DFL, DBL, DBR
+
+ CENTERS: U, L, F, R, B, D
+
+ For example,
+
+ will have the UR edge invisible.
+
+ # ---------- Other puzzles ----------
+ Very similar, except we generalize the format "EDGES:xxxxxxxxxxxx,CORNERS:xxxxxxxx,CENTERS:xxxxxx"
+ Replace EDGES, CORNERS, and CENTERS with the names of the piece orbits as defined in cubing.js.
+ - pyra: EDGES, CORNERS, CORNERS2
+ - 5x5: EDGES, EDGES2, CORNERS, CENTERS, CENTERS2, CENTERS3
+ To find the names of these orbits for any puzzle, go to https://experiments.cubing.net/cubing.js/twisty/twisty-player-props/
+ Look at the kpuzzle box, and try to copy the entire contents of that box. orbitNames is what you need.
+
+ Then, each orbit name is followed with characters from the table above, to sticker the pieces of that orbit.
+ Please ensure the number of characters matches the number of pieces in that orbit, otherwise you may get errors.
*/
// adapted from https://github.com/cubing/cubing.js/issues/224#issuecomment-1275928713
@@ -130,4 +188,4 @@ async function transformTPMask(twisty: TP, transformationSource: Alg | string) {
}
twisty.experimentalStickeringMaskOrbits = newMask;
-}
\ No newline at end of file
+}
diff --git a/components/index-page/index.module.css b/components/index-page/index.module.css
new file mode 100644
index 0000000..e69de29
diff --git a/components/index-page/index.tsx b/components/index-page/index.tsx
new file mode 100644
index 0000000..f6d8b42
--- /dev/null
+++ b/components/index-page/index.tsx
@@ -0,0 +1,11 @@
+import styles from "./index-page.module.css"
+import { Link } from 'nextra-theme-docs'
+
+// Usage in MDX: export { IndexPage as default } from '@components/index-page'
+export const IndexPage = () => (
+
);
}
diff --git a/pages/en/_meta.tsx b/pages/en/_meta.tsx
index 9c13489..c91d862 100644
--- a/pages/en/_meta.tsx
+++ b/pages/en/_meta.tsx
@@ -1,17 +1,32 @@
export default {
- "index": "Introduction",
- "about": {
- "title": "About",
- "type": "page"
- },
- "tutorial": "ZZ Tutorial",
- "improvement-guide": "How to Improve",
- "example-solves": "ZZ Example Solve Library",
- "blog": {
- "title": "Blog",
- "type": "page",
- "theme": {
- "sidebar": false
+ index: {
+ title: "Intro",
+ display: 'hidden',
+ theme: {
+ // layout: 'raw'
+ breadcrumb: false,
+ timestamp: false,
+ sidebar: false,
+ toc: false,
}
- }
-}
+ },
+ roux: {
+ title: "Roux Method",
+ type: "page",
+ },
+ zz: {
+ title: "ZZ Method",
+ type: "page",
+ },
+ "method-dev": {
+ title: "Method Development",
+ type: "page",
+ },
+ blog: {
+ title: "Blog",
+ type: "page",
+ theme: {
+ sidebar: false,
+ },
+ },
+};
diff --git a/pages/en/blog.mdx b/pages/en/blog.mdx
index 33f5b2b..cf2529c 100644
--- a/pages/en/blog.mdx
+++ b/pages/en/blog.mdx
@@ -1,5 +1,5 @@
---
-title: ZZ Blog
+title: Cubing Methods Blog
description: A helpful blog written by ZZ solvers.
---
diff --git a/pages/en/blog/story.mdx b/pages/en/blog/story.mdx
index 5b9431b..130c43d 100644
--- a/pages/en/blog/story.mdx
+++ b/pages/en/blog/story.mdx
@@ -45,8 +45,7 @@ We needed to create interactive 3D cubes that would show how EO worked.
Thankfully, [`cubing.js`](https://js.cubing.net/cubing/) is an amazing tool that helped us build these visualizations.
- Check out [Yoruba's 50 example solves!](/example-solves/yoruba-7.19-ao50)
+ Check out [Yoruba's 50 example solves!](/zz/example-solves/yoruba-7.19-ao50)
-If you're interested in contributing to the library, learn [how to submit your solves here](/example-solves#submissions).
+If you're interested in contributing to the library, learn [how to submit your solves here](/zz/example-solves#submissions).
diff --git a/pages/en/improvement-guide/eocross.mdx b/pages/en/improvement-guide/eocross.mdx
deleted file mode 100644
index c33ef67..0000000
--- a/pages/en/improvement-guide/eocross.mdx
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: EOCross Improvement Guide
-description: An introduction to the EOCross improvement guide.
-author: crystalcuber
----
-
-Introducing the comprehensive EOCross guide! It breaks down the most complex step of ZZ with systematic approaches.
-Included is the Movecount Drill, an exercise with proven results for increasing EOCross efficiency.
-
-[Start here!](/improvement-guide/eocross/eocross-full-guide)
diff --git a/pages/en/improvement-guide/eocross/color-neutrality.mdx b/pages/en/improvement-guide/eocross/color-neutrality.mdx
deleted file mode 100644
index d097321..0000000
--- a/pages/en/improvement-guide/eocross/color-neutrality.mdx
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: Color Neutrality
-description: Learn what Color Neutrality is and how to apply it to the ZZ Method.
-author: yoruba and crystalcuber
----
-
-**Color Neutrality (CN)** is the ability to solve on multiple different cube orientations equally well. For example, a color neutral ZZ solver may be equally comfortable solving any color of EOCross. Color neutrality is very helpful for EOCross, as having more options will allow you to choose a faster and more efficient option.
-
-In this page, we will explain how CN works and how to learn the main options for ZZ method speedsolving.
-
-## Definitions
-
-**Cube orientation** is the angle at which the cube is held, based on the position of the center pieces. For example, scramble orientation is the conventional way to hold the cube during scrambling, with the white center at the top and green center at the front. Usually, cube orientations are described by the top and front centers, and abbreviated like "white top green front".
-
-An **EO axis** (plural: axes) is a pair of two centers at the Front or Back that determine which edges are good or bad. For example, if a scrambled cube has the orange center at the Front and red center at the Back, that is the orange/red or red/orange axis. From the [EO tutorial](/tutorial/eo), we learned that the bad edges may change when holding the cube in different orientations. However, as long as the orange/red centers are both at the Front/Back in any order, the bad edges will actually be the same. In total, there are three EO axes on the cube (red/orange, green/blue, white/yellow).
-
-EOCross is a combination of solving the cross pieces of a certain color, and solving the EO of a certain axis.
-
-## Types of CN
-
-### Fixed
-
-**Fixed** means always starting the solve from one specific cube orientation. This gives you only one EO axis and one cross color to work with, so there is only one EOCross option to consider. One might also notice that you can do a y2 to get the same EO and cross, which is true (we will go over this in the [practicing](/improvement-guide/eocross/practicing) article).
-
-The most common choice by beginners, which can also be solid at a high level.
-
-The main advantage for fixed solvers is better piece recognition, due to getting used to a single cross color and EO axis. This can be a great boost to lookahead.
-
-The downside is worse EOCross efficiency because only one EOCross is considered. Later on, this could create problems with planning the first F2L pair.
-
-### x2y
-
-**x2y** is the practice of solving on two opposite cross colors. For example, an x2y solver may choose to solve the white cross or yellow cross. For each cross color, there are two possible EO axes to choose from, giving a total of four distinct EOCross options. For instance, that solver would choose from:
-
-- White cross, green/blue EO axis
-- White cross, red/orange EO axis
-- Yellow cross, green/blue EO axis
-- Yellow cross, red/orange EO axis
-
-x2y is the most popular option amongst top solvers. This allows you to choose significantly better EOCrosses than a fixed solver, while not having to go through the hassle of becoming full CN. It can be considered as a balance between these two options.
-
-x2y EOCrosses at the highest level average about 7-9 moves on average and low 1s in execution.
-
-### Full CN
-
-**Full CN** is the ability to choose any EOCross. This means considering any combination of cross color and EO axis. Contrary to popular belief, full CN is possible in ZZ. In total, there are 12 distinct EOCross options to check.
-
-Full CN is the most efficient option, with solutions ranging from 5-8 moves. Because the EOCross solutions are generally shorter, the first F2L pair is easier to plan. The solutions can also be ergonomic and fast to execute (sub 1 second).
-
-The biggest disadvantage is increased inspection time spent on EOCross. In addition, F2L piece recognition is much harder to master. However, it could be argued that the reward is worth the effort.
-
-### Which one to choose?
-
-We recommend x2y or full CN. Both provide fast EOCrosses that are efficient enough to allow planning the first pair later on.
-
-For the rest of the tutorial we will choose x2y since the writer is more experienced in that option.
diff --git a/pages/en/improvement-guide/eocross/practicing.mdx b/pages/en/improvement-guide/eocross/practicing.mdx
deleted file mode 100644
index 2df12ee..0000000
--- a/pages/en/improvement-guide/eocross/practicing.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
----
-title: Practicing for Speed
-description: Drills and advice for practicing your speed in the ZZ Method.
-author: yoruba
----
-
-## Turning
-
-An essential skill for EOCross is the ability to execute solutions involving many different types of moves. That’s why we need to adapt a repertoire of fingertricks, especially for executing F/B moves. Be able to do:
-
-- U/D flicks
-- U2/D2 flicks (or get very good at double single flicks, Max Park style)
-- U/D pushes
-- U drags
-- Being able to do U and D moves at the same time
-- F moves with thumbs
-- Rolling R/R2/L/L2 moves
-
-Then for F/B moves in general, execute them as U/D from the thumb on top/bottom grip.
-
-What you should prioritize is developing a high quality turning style. Here's how to do it:
-- Prioritize turning accuracy. Make sure you allign each layer correctly on every turn. The way you can think about this is to complete each turn fully instead of rushing through moves.
-- Relax your hands and don't use too much force. For this you may need to switch to a faster cube or apply a lubricant that speeds up your cube.
-- Use the tips of your fingers, instead of the pads. This will make the moves quicker as turning with the tips requires less physical movement.
-
-You can practice these techniques by doing untimed solves before a solving session where you focus on good turning.
-
-There are 2 areas to improve in solving the EOCross faster: Solutions and Execution.
-
-## Solutions
-
-While it is important, low movecount isn't everything. We want our solutions to also be executed quickly: After all, the end goal is to solve the EOCross as fast as possible, not to be as efficient as possible. Ergonomics and ease of planning can justify a longer solution, even if it takes 10 or 11 moves. Here's some tips on optimizng your solutions for speed:
-
-### Ergonomics
-
-- Don't go for solutions that have a lot of F2/B2 moves. In your solution, one such move is fine, two such moves should be reasonably justified and never do them 3 times or more.
-- [Color neutrality](/improvement-guide/eocross/color-neutrality) helps a lot here. CN and x2y solvers will have a lot of advantage over fixed solvers for being able to choose between multiple options.
- - Executing your planned solution from a y2 away can greatly improve the ergonomics of your solution. You can do that, because after a y2, the EO axis and the cross color stays the same. This is most used during solutions with a lot of singular B moves, in these cases you can just do a y2 to turn the B moves into easier to execute F moves.
- Here's an [example](https://alpha.twizzle.net/edit/?stickering=EOcross&setup-alg=U'+L2+U2+B2+U+R2+D+F2+R2+D+R2+D'+L'+U'+R+B'+U+B+R+B2+D&alg=%2F%2Fwe+can+solve+this+case+with+L'+B'+D'+B'+L+R2%2C+however%2C+the+ergonomics+are+pretty+bad.+We+can+instead+do+a+y2+before+the+solution%3A%0Ay2+R'+F'+D'+F'+R+L2+%2F%2Fand+thats+much+nicer+to+execute).
-- Prioritize solutions with triggers in them.
-- The first move is important. With stackmat, it will be preferable for the first move you do to be a U/D move. If your solution starts with an F/B move, just rotate x/x' before a solve to make this move U/D. As for which moves are the best to start: It depends on the grip, but generally, U/D and single R/L moves are the best, with F/B moves on the same level (if executed from a rotation away as stated before), and finally R2/L2 moves.
-
-### Simplicity
-
-Simplicity is key. You will find that simpler solutions with 1-2 moves less efficient will actually be the best for TPS. This will also help in inspection, so that you don't have to spend more time than necessary planning the EOCross. Here's an [example](https://alpha.twizzle.net/edit/?stickering=EOcross&setup-alg=D+L2+B2+L2+D%27+B2+D2+F2+U2+R2+U+B+D2+F%27+D%27+R%27+B2+U+L2+U&alg=%2F%2F+U2+B+D2+L2+D%27+R%27+F+-+a+complex+7+move+solution%2C+would+also+take+a+lot+of+time+in+inspection+to+see.%0A%2F%2F+Here%27s+a+much+simpler+alternative%3A%0AB+R2%27+%2F%2F+Partial+EO+%2B+2%0AD+F+L+F%27+L%27+%2F%2F+finish+EO+while+inserting+the+cross+edge%0AR+%2F%2F+finish%0A%2F%2F+It%27s+only+1+move+longer%2C+butit%27s+way+faster+to+see+and+most+importantly%2C+much+more+ergonomic).
-
-But what was the point of improving movecount if simpler, less efficient solutions are faster?
-
-Because we still want to know how to deal with the harder scrambles, after all, not every solution will be obvious. Also, more often than not, move efficient solutions turn out to be more ergonomic. The point of this is that we don't want to do a computer optimal solution with horrid ergonomics when there's a much faster option for 1-2 moves sacrifice.
-
-## Execution
-
-On how to better execute your EOCross:
-
-- Go over the [Solutions](#solutions) section above. Better solutions will of course be better executed.
-
-- Work on your turning. Apply the tips and fingertricks from the [Turning](#turning) section so that you are able to turn fast and accurately in solves with some practice. Accuracy is far more important, as locking up on a move is worse than turning slightly slower.
-- In your solutions, find strings of moves that could be done like a trigger.
-
- For example, `B' R2 B'`: You can either: Start with thumb on bottom, do `B'` with right ring, `R2`, and then `B'` with right index. Or the opposite: Start with thumb on top, do `B'` with right index, `R2'`, do `B'` with right ring.
-
-- Reduce the amount of regrips you do. Make sure that you're not doing any unnecessary regrips during your solution, if you think you regrip too much, go over the solution that you have done. The best thing you could do is to learn multiple fingertricks for U/D moves in different grips so that you don't have to switch to a specific grip to do U/D/F/B moves, for example B' like in the example previously mentioned. Refer to the [Turning](#turning) section to see if you can apply any to reduce the regrip count, as well as try different grips to see if you can execute a set of moves faster.
-
-Finally, to apply these tips in practice, we can use a modification of the previously mentioned Movecount Drill: but instead of typing in the amount of moves that the EOCross took, we type the time that it took us to solve EOCross from stackmat. Then go over the scrambles that took the most time to solve EOCross, or that went above the 'target time'.
-
diff --git a/pages/en/improvement-guide/eocross/xeocross.mdx b/pages/en/improvement-guide/eocross/xeocross.mdx
deleted file mode 100644
index d089a71..0000000
--- a/pages/en/improvement-guide/eocross/xeocross.mdx
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: XEOCross
-description: Learn XEOCross, a technique that can sometimes be used to give your ZZ solve a head start.
-author: yoruba
----
-
-import TwistyPlayer from "components/TwistyPlayer";
-import { Callout } from "nextra/components";
-
-**XEOCross** is an EOCross and one F2L pair, both solved at the same time. It stands for eXtended EOCross, and looks like this:
-
-
-
-You won't be able to do an XEOCross in every solve. The best option is often to solve an EOCross and then your first pair separately. However, if there is an easy XEOCross then it can give your solve a head start.
-
-## XEOCross strategies
-
-There are two main ways to tackle an XEOCross:
-
-### Blockbuilding
-
-**Blockbuilding** is a general technique of forming rectangular sections of solved pieces, called **blocks**.
-
-This is useful in XEOCross because it can be thought of not just as an EOCross and an F2L pair, but as a 2x2x2 block and two cross edges. If there are easy or pre-made blocks on the scramble, this strategy can be effective.
-
-Here's an example: [Example 1](https://alpha.twizzle.net/edit/?title=XEOCross+Example+1&puzzle=3x3x3&alg=R%27+B+U%27+F+D+R%27+%2F%2FXEOCross&setup-alg=D%27+B2+D2+U+R2+D2+R2+B2+R2+F%27+L+B%27+U2+R%27+L%27+U+R2+L%27+U2). There is an easy 2x2x1 block (yellow-green-orange) which can be expanded into a 2x2x2 block by filling in the FL edge. Putting them together with the remaining 2 cross edges created an XEOCross.
-
-In [Example 2](https://alpha.twizzle.net/edit/?title=XEOCross+Example+2&setup-alg=U2+B+L+F%27+D%27+B+D+R+L2+B2+D%27+B2+U+R2+U2+B2+D%27+F2+D+F&alg=x2+y+%2F%2F+inspection%0AU+R%27+B%27+%2F%2F3+bad+edges+%2B+inserting+a+cross+edge%0AL+F+U%27+D%27+F%27+%2F%2Fsolving+EO%2B3%2C+making+sure+that+we+don%27t+break+the+block%0AD+R%27+%2F%2F+finish), we see a pre-made 2x2x1 block that we can preserve to form a 2x2x2.
-
-### Keyhole
-
-
- Prerequisite: Get comfortable with [keyhole
- F2L](/improvement-guide/zzf2l/pair-solutions#edge-keyhole).
-
-
-If you see that an F2L edge or a corner ends up solved after an EOCross, you can try to keyhole insert the remaining edge/corner. (This ties into planning more than EOCross in inspection and seeing ahead into your F2L). Here’s an example: [Example 3](https://alpha.twizzle.net/edit/?title=XEOCross+Example+3&puzzle=3x3x3&setup-alg=F2+U%27+L2+U%27+L2+D+B2+F2+R2+D+L+U2+F%27+U+B%27+D+U%27+R+D2+B&alg=y%27+%2F%2F+Let%27s+say+you+planned+U+L+R%27+U%27+F%27+D2+F2+R+D%27+for+your+EOCross.+Notice+that+after+the+first+5+moves%2C+the+yellow-red-green+2x2x1+block+has+formed.+Let%27s+see+if+we+can+also+solve+the+red-green+edge+that+turns+it+into+a+2x2x2.%0A%0AU+L+R%27+U%27+F%27+%2F%2F+Here%27s+our+block.%0A%0AD2+F2+%2F%2F+We+can+see+the+red-green+edge.+Before+the+following+R+move%2C+we+can+add+a+U%27+which+will+make+the+R+solve+the+red-green+edge+in+addition+to+the+cross+edge.+This+is+a+strategy+called+Keyhole%21%0A%0AU%27+R+D%27+%2F%2F+And+there%27s+our+XEOCross%21)
-
-If you plan your first pair, and it turns out to be a keyhole solution, you can also incorporate that in your solve: [Example 4](https://alpha.twizzle.net/edit/?title=XEOCross+Example+4&puzzle=3x3x3&setup-alg=D2+L2+D+L2+U+R2+D+B2+R2+U+B2+U2+L+U%27+B2+D2+F+L+D+B%27+U&alg=x2+y+%2F%2F+inspection%0A%2F%2F+Let%27s+say+you+planned+this+EOCross%3A+U+B%27+L%27+F+U2+R2+D+R+D%27.+You+also+planned+the+BL+pair%2C+which+you+would+solve+with+keyhole%3A+D+U%27+L%27+U%27+L+D%27.+We+can+just+cancel+the+moves%2C+which+gives+us%3A%0AU+B%27+L%27+F+U2+R2+D+R+U%27+L%27+U%27+L+D%27+%2F%2F+XEOCross.)
diff --git a/pages/en/improvement-guide/ll/zbll-guide.mdx b/pages/en/improvement-guide/ll/zbll-guide.mdx
deleted file mode 100644
index 727397d..0000000
--- a/pages/en/improvement-guide/ll/zbll-guide.mdx
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: ZBLL Full Guide
-description: How to learn ZBLL, step-by-step.
-author: yoruba
----
-
-import { Callout } from "nextra/components";
-
-So you want to learn ZBLL? We got you covered - here's how to learn it step by step.
-
-
- Before you begin learning ZBLL, make sure that you know OCLL/PLL and have good
- turning.
-
-
-## Mindset
-
-First off, let's debunk a few common negative beliefs that you may have before continuing.
-
-_Too many algs:_ single most common addressed issue. The truth is that the most bang for your buck would be learning ZBLL without sune and antisune, which is 328 algs. That still may seem a lot, but if you dedicate yourself to learning a set of 12 algs per week, then you could learn and master them all in 7 months. If you're reading this article on the month of publication (December 2023), then you could become a great ZBLL user by July 2024.
-
-_Can't maintain:_ now people might say that ZBLL is possible to learn, but that it would require too much work to keep the algorithms drilled.
-
-If you, as before stated, spend a week on a set, that's more than enough time to get the algs to a good speed (sub 1.5 at least, preferably sub 1.2). Then after that week of grinding you could make consistent quick 3-5 minute reviews of the cases so that they stay in your muscle memory. Along with that, by just doing solves, you will be getting these cases quite frequently, since you're guaranteed on getting a ZBLL case. So by just doing that, the algorithms will stay fresh in your memory.
-
-Now I'm telling you to learn a set in a week, but how should you structure that week?
-
-It depends on how quickly you want to learn the algs, but let's say you will learn a set in 3 days. Then the remaining 4 days will be spent on practicing this set by alg drilling, using the ZBLL trainer, etc.
-
-Before you start, I would highly recommend making your own ZBLL sheet to keep your algs organized. How to make one? Just make a copy of an already existing ZBLL sheet on google docs, and switch out the algorithms to the ones of your liking.
-
-With that out of the way, let's begin.
-
-## Order of learning
-
-We're going to learn ZBLL by the OCLL sets, the most agreed upon order is T/U, L, H/Pi.
-
-Then for each OCLL set, the preferable way to learn is by practicing the 2GLL set first, then the Diag set, and finally the 4 remaining adjacent sets.
-
-The reason for this path of learning is that you're starting with the sets that are the most beneficial to learn, that way by learning them first you're going to have them practiced and drilled in your memory the most.
-
-## Recog
-
-Of course, you also need to know how to recognize the cases from each other. There are multiple ways, but the most consistent is Baum-Harris. Learn more about recog [here](/improvement-guide/ll/zbll-recog).
-
-## Learning a set
-
-Choose your algorithms by going through the [ZBLL sheets](/improvement-guide/ll/zbll-algs). Try out different algs and check which ones work the most for you. Just a tip: do not overthink this process. You might fall into the trap of being too indecisive about choosing between 2 algs that probably have a 0.1 difference between them at best. If you ever catch yourself in this situation, pick whichever. You can always switch out the alg later. Add them to your own sheet.
-
-To practice these algs, here's [everything covered for you.](/improvement-guide/ll/zbll-practice)
-
-## Maintaining a set
-
-After you learn a set, you will have to review it again at certain times to not forget it. You don't need to go through the whole practice process again, but you want to address through the following: muscle memory of the algs, alg-case connection, AUF stickers. This can take you 3-5 minutes if you have made a zbll sheet beforehand.
-
-Use spaced repetition: So after learning a set, review it daily for 5 days, then 3 times every 2 days, then you only need to review it once a week. This is called spaced repetition.
-
-And that's it! Your ZBLL journey will consist of learning a new ZBLL set every week, and reviewing these sets every once in a while to not forget them. Good luck on your journey!
diff --git a/pages/en/improvement-guide/zzf2l.mdx b/pages/en/improvement-guide/zzf2l.mdx
deleted file mode 100644
index 0bbf476..0000000
--- a/pages/en/improvement-guide/zzf2l.mdx
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: ZZF2L Improvement Guide
-description: An introduction to the ZZF2L improvement guide.
-author: crystalcuber
----
-
-Welcome to the comprehensive ZZF2L guide on ZZMethod.com!
-These tutorials, practice drills and advice can take your F2L to the next level.
-
-This guide is for EOCross ZZF2L. For EOLine ZZF2L, refer to [Conrad Rider's guide](http://cube.rider.biz/zz.php?p=f2l).
-
-[Start here!](/improvement-guide/zzf2l/zzf2l-full-guide)
diff --git a/pages/en/improvement-guide/zzf2l/deduction.mdx b/pages/en/improvement-guide/zzf2l/deduction.mdx
deleted file mode 100644
index b7047a3..0000000
--- a/pages/en/improvement-guide/zzf2l/deduction.mdx
+++ /dev/null
@@ -1,130 +0,0 @@
----
-title: ZZF2L Piece Deduction
-description: Identify pieces during ZZF2L without needing to peek at the back/bottom sides.
-author: yoruba and crystalcuber
----
-
-import { Callout } from "nextra/components";
-import TwistyPlayer from "components/TwistyPlayer";
-
-# What is deduction?
-
-During F2L, one of the challenges is determining where your F2L pieces are. Some pieces are **visible in plain sight:** we can see all of their stickers on the **front, top, left and right sides** of the cube. However, other F2L pieces are partially or completely hidden from plain sight.
-
-**Deduction** is the ability to identify them without having to peek at the bottom or back sides. There are 3 levels of deduction:
-
-## Easiest: all stickers visible
-
-
-
-{/* TODO: insert link to piece notation article */}
-These are the pieces that have all of the stickers visible on the front, top, left and right sides of the cube. In piece notation, they are the UFR/UFL corners and the UL/UF/UR/FL/FR edges. No deduction is needed.
-
-## Medium: corners with 2 stickers visible
-
-
-
-These corners (marked in yellow) can be deduced from looking at 2 of their stickers alone, because that's all you need to identify a corner. They are the DFL/DFR/UBL/UBR corners.
-
-To deduce a corner with just 2 stickers:
-
-- The colours of the 2 stickers mean it could be either one of two corners (that have both colours).
-- The order of the 2 stickers determines which of those two corners it is.
-
-To train this skill, use [the Coracle drill](http://cube.rider.biz/coracle.html) by Conrad Rider. Do untimed solves where you try to identify corners with only 2 stickers. After some practice, 'medium' pieces will be as easy to identify as 'easiest' pieces.
-
-## Hard: 1 sticker visible
-
-
-
-These pieces (marked in red) are impossible to deduce by themselves (UB/BR/BL edges + DBL/DBR corners). You need to look at other pieces to eliminate possibilities.
-
-### Process of elimination
-
-A general strategy to deduce 'hard' pieces is to eliminate options based on 'easy' or 'medium' pieces you can see. For example, suppose we want to deduce the BL edge:
-
-
-
-Looking at the BL edge alone, we cannot deduce it because we can only see a single (orange) sticker. But we can use the process of elimination on all edges that have orange on them:
-
-- ❌orange-white (cross edge): cross is already solved, we never consider cross edges.
-- ❌orange-yellow (LL edge): it's at the UF position in plain sight.
-- ❌orange-blue (F2L edge): it's at the UL position in plain sight.
-- ✅orange-green (F2L edge): then orange-green has to be the BL edge.
-
-When you can only see 1 sticker of a piece, there are always 4 options. The nice thing with edges is that you don't need to consider the cross edges because EOCross is already solved, so for edges typically you consider 3 options: one LL edge + two F2L edges.
-
-For corners, you can also use the process of elimination, but it's slightly harder and less consistent. However, if you know exactly what corner you're trying to identify (so a red-green-white for example), you can identify it by just 1 sticker.
-
-This process of elimination becomes easier when more F2L pairs are solved because there are fewer options. With practice, this skill will no longer feel like a detective game. It will become instinct.
-
-### LL edge rule
-
-Because EO is solved, there is a rule you can use for the 'hard' UB edge and even the 'easy' FL, FR, UL, and UR edges:
-
-
- If an edge doesn't have a U sticker on top, it can't be a LL edge. **It must
- be an F2L edge.**
-
-
-U sticker means any sticker that matches the colour of the U center.
-
-
-Explanation:
-Since EOCross is solved, all bottom edges are solved. So during F2L, there are two types of edges: F2L edges (belonging to an F2L pair) and LL edges. LL edges belong to the top (U) layer, so they'll always have a U sticker.
-
-Typically, you need to see both stickers of an edge to tell if it's a LL edge. However, there is a special rule for stickers on the ['purple orbit'](/tutorial/eo#orbits). Because EO is solved, U stickers will always be on the purple orbit. This means: if an edge is an LL edge, you will see a U sticker on the purple orbit. If you don't see a U sticker there, the edge is an F2L edge.
-
-
-
-You can use this rule together with the process of elimination. Here's an example:
-
-
-
-Suppose we want to identify the UB edge. We can only see its top sticker, which is green. Normally, with process of elimination we must consider the three possible edges:
-
-- ❓green-yellow (LL edge): it's a 'hard' piece, is it at UB or BR?
-- ❌green-red (F2L edge): it's an 'easy' piece, we see it at UF.
-- ❓green-orange (F2L edge): it's a 'hard' piece, is it at UB or BR?
-
-But the LL Edge Rule says: the UB edge doesn't have a U sticker on the purple orbit (it doesn't have yellow there), therefore it's an F2L edge. This is perfect, because it eliminates the green-yellow LL edge which we weren't sure of.
-
-- ❌green-yellow (LL edge): nope because of UB Edge Rule.
-- ❌green-red (F2L edge): it's an 'easy' piece, we see it at UF.
-- ✅green-orange (F2L edge): green-orange is UB!
-
-### Track pieces beforehand
-
-One more strategy for 'hard' pieces is to [lookahead during F2L](/improvement-guide/zzf2l/lookahead) and track pieces that you are not currently solving. Some pieces you track can start visible, but after solving a F2L pair they end up on the back. If you watch where pieces are moving, you can identify a 'hard' piece before it even becomes 'hard'.
diff --git a/pages/en/improvement-guide/zzf2l/multislotting.mdx b/pages/en/improvement-guide/zzf2l/multislotting.mdx
deleted file mode 100644
index dab3943..0000000
--- a/pages/en/improvement-guide/zzf2l/multislotting.mdx
+++ /dev/null
@@ -1,131 +0,0 @@
----
-title: Multislotting
-description: Solving two or more F2L pairs at once in the ZZ Method.
-author: yoruba
----
-
-import TwistyPlayer from "components/TwistyPlayer";
-
-**Multislotting** is the act of solving 2 (or more) pairs at once. This is very advanced and will cut out your movecount and time by a significant margin.
-
-Prerequisite: Achieve a 'knowing' level of lookahead. Before solving a pair, you spot the pieces of another pair beforehand and immediately know where the pieces are going to end up.
-
-Why do that? It will give you a general understanding of when to apply multislotting or not. A lot of the time, solving 2 pairs individually is going to be the fastest way of solving them. Knowing for example, that after solving a pair, your other pair will become an 11 mover or a free pair, you're going to know when to apply it.
-
-## Influencing
-
-**Influencing** is the simplest and most elegant form of multislotting. It means altering the solution of the pair you're solving to force a better case for your other pair. This requires knowing multiple solutions for cases, although a lot of them are pretty similar (example: inserting the pair with `U2` insert instead of `U'`).
-
-
-
- Good solution (shown above): insert FR with `U2`, resulting in a 3-move BR
- pair.
-
-
`(U R U2 R') (R' U R)`
-Bad solution: insert FR with `U'`, resulting in an 11-move BR pair.
-
`(R U' R') U2 (R' U R U R' U R U' R' U R)`
-
-
-
- Good solution (shown above): insert FL with `U2`, resulting in a 3-move FR
- pair.
-
-
`(U2 L' U2 L) U (R U' R')`
-Bad solution: insert FL with `U'`, resulting in an 11-move FR pair.
-
`(U' L' U L) U' (R U' R' U' R U' R' U R U' R')`
-
-The opposite may also be true: the U2 insert results in a bad case, while the `U/U'`
-doesn't.
-
-
-Good solution (shown above): insert FL with `U`:
-
`(U L' U L) U2 (R U R')`
-Bad solution: insert FL with `U2`:
-
`(L' U2 L) U (R U' R' U' R U' R' U R U' R')`
-
-Influencing is mostly useful when, as stated before, you realize that after solving a pair normally, you get a very bad case. That's when you can try doing a different solution to alter the case to something better.
-
-## Pseudoslotting
-
-Remember [keyhole](/improvement-guide/zzf2l/pair-solutions#edge-keyhole)? Pseudoslotting is basically that, but you solve both an edge of one pair and the corner of another pair to solve 2 pairs at once. You can treat the edge and corner that you're solving much like a F2L pair, but because they don't match, the recognition relies entirely on the position of the two pieces and the orientation of the corner.
-
-Here's an example: DFR and FL are solved. If open slots are available, you could use keyhole to solve the DFL and FR pieces one-by-one, like this:
-
-
-
- Keyhole the FR edge, then the DFL corner: `(D R U2 R' D') (D2 R' U' R D2)`
-
-
-With pseudoslotting, you can do that all at once. Here, we can do a D move to align the unsolved corner and edge spots, forming a "pseudo-slot". Then we treat the DFL corner and FR edge much like a regular F2L pair:
-
-
-Moves: `D (R U R' U2 R U' R') D'`
-
-The advantages of pseudoslotting compared to doing keyhole twice:
-
-- Works even with no other open-slots.
-- Fewer D moves for better ergonomics, and often fewer moves in total.
-- Recognition in one step.
-
-That's cool when it appears, but you can also force a pseudoslotting case! If we have an edge or a corner solved, we can insert the other corner/edge and then pseudoslot. This is very overpowered, but make sure you're forcing a case that makes sense.
-In this example, the regular F2L pairs are both 7-movers, not great. But an edge is solved, so we can solve a corner of another slot. Then, pseudoslot!
-
-
-Moves: `(R U' R') (D R U' R' D')`
-
-When to force? You will see from practice and experimenting, but generally when you can solve both pairs in 8-9 moves this way (like the above example) it's good to use it.
-
-## Pseudo F2L
-
-Where you offset your EOCross by a D move (or any D move to that extent) and solve the pieces from here like you would do in pseudoslotting. The main aspect is that sometimes you shouldn't do this for the entirety of F2L: you could do this for 2 pairs but then have normal free pairs appear, this is when you should switch.
-
-This technique is difficult to learn also mainly for pair recognition: you would have to get accustomed to the colours of your pseudo pairs, which will require a lot of practice.
-
-Once mastered however, it's a very powerful tool. You'll be able to cut down your movecount significantly and be able to get sub 50 move solutions with ease when the opportunity arrises.
-
-## Algorithms
-
-Now, some multislotting cases (mainly Last 2 pairs) are pretty complicated in terms on what influencing or pseudoslotting technique you should use, and some cases are just so bad even with these techniques that you could use algorithms for them, although these cases will be rare if you have good pair choice. Biggest example is when you have 2 pairs solved, and the rest of the F2L pieces end up in the F2L slots but not inserted in their spots or the corners may end up misoriented, which are worthwhile learning sets with not that many algorithms in them.
-
-You can use the currently available multislotting alg sheets to learn algs for these cases, although think about this when you have already mastered the other aspects of F2L.
-
-[ZZ Last 2 Pairs Sheet](https://docs.google.com/spreadsheets/d/15-CPzqr07A1vCrwaRlXcSiR4lYVycMsgMakb0TIwp0g/edit#gid=224228038)
diff --git a/pages/en/improvement-guide/zzf2l/pair-solutions.mdx b/pages/en/improvement-guide/zzf2l/pair-solutions.mdx
deleted file mode 100644
index be06cd8..0000000
--- a/pages/en/improvement-guide/zzf2l/pair-solutions.mdx
+++ /dev/null
@@ -1,127 +0,0 @@
----
-title: F2L Pair Solutions
-description: Improve ZZF2L speed by learning the best solutions for pairs.
-author: yoruba
----
-
-import TwistyPlayer from "components/TwistyPlayer";
-
-## Introduction
-
-At the highest level, you want to make sure that you're using speed-optimal solutions for the majority of the F2L cases you're going to solve. This will cut down your movecount by a significant margin and make the solve much simpler and faster.
-
-Here you will learn how to implement such solutions and incorporate them into your solving.
-
-{/* ## Progressing from intuitive F2L */}
-
-{/* TODO: work in progress! */}
-
-{/* [link](/tutorial/zzf2l) */}
-{/* (section here, to be written, tldr: be smarter about the ways to take out the pieces of the slot and how you insert them, should take 2 triggers max yada yada.First i need to know how the Intuitive F2L article will look like though) */}
-
-{/* ## Optimizing solutions more */}
-
-{/* Your solutions are more efficient now, but we want them as best as they can be. When we use the previous technique, we might still not be solving the cases the fastest. That's why we will start using resources to make our solutions speed optimal. */}
-
-## Main resource: ZZF2L doc
-
-[ZZF2L doc](https://docs.google.com/spreadsheets/d/13O15zHAd0rKU9V9VQHw1vLEQh7v5fpWzeajokjz8LgA)
-
-This is the resource you would want to use, it covers every single possible pair you can get in ZZ, as well as alternative solutions to different combinations of **open slots**. A fantastic resource, it's all you need to optimize your pair solutions.
-An "open slot" is a slot with unsolved pieces.
-
-To accompany you, you can also use ZZ example solves. High level CFOP recons are OK too, but make sure that the solutions they do preserve EO.
-
-### How to use it?
-
-You can learn F2L pair solutions by going through F2L untimed, and whenever you feel like you solved an F2L pair inefficiently, just check the doc. This is a completely viable way to learn, as you learn these solutions on the fly as they appear in your solves. You do not need to try to memorize all cases at once like you might with last layer algs.
-
-Each tab of the spreadsheet has solutions for all 4 slots. The FR tab has all cases for the front-right slot, so most solutions are simply mirrors of the FL (front-left slot) tab.
-
-## Last Slot
-
-The last slot (LS) where you want to optimize solutions first, as they are the least intuitive, so you want to get them out of the way first.
-
-Use the doc and check the LS solutions for all 4 slots to see if you could use a better solution.
-
-For the majority of the pairs, they will usually have 1 solution that is speed optimal and considered best. For the worse LS cases, there are typically 2-3 that you can choose from, although they vary in speed by 0.1 seconds at most, so it doesn't matter which one you choose.
-
-Tip: it's good to know all of them later, as they can help in forcing better OCLLs.
-
-## Free slots
-
-When optimizing efficiency more, take note of the alternative solutions that prioritize free slots. For example, `R U2 R2 U' R2 U' R'`. The last 3 moves are just there to restore the FR pair.
-
-{/* note: basic pattern for F2L stickering is EDGES:DDDDIIIIDDDD,CORNERS:DDDDIIII,CENTERS:DDDDDD */}
-
-
-
-But with the FR slot open, there's no need for that. This mean the case could now be solved with just `R U2 R2 U' R`:
-
-
-
-One example of these free slot solutions is **keyhole:** when you have a slot with only one solved piece, you can leverage an open slot to insert the other piece.
-
-1. Bring the other piece to the U layer if it's not there already.
-2. Do a certain D move.
-3. Insert the other piece.
-4. Undo the D move.
-
-### Edge keyhole
-
-When inserting an edge, the D move in Step 2 should be to move the solved corner out of the way, replacing it with an unsolved corner from the open slot.
-In Step 3, insert the edge into the slot that it belongs to. Here's an example:
-
-
-Moves: `D' R U' R' D`
-
-We take advantage of the open BR slot. The edge we want to insert is already on the U layer.
-So we can do `D'` to move the solved corner out of the way.
-Then `R U' R'` to insert the edge to the slot it belongs to, and `D` to undo the first D move.
-
-### Corner keyhole
-
-When inserting a corner, the D move in Step 2 should be to move the spot the corner belongs to into the open slot. In step 3, insert the corner into that open slot. Press ▶️ to see an example:
-
-
-Moves: `D' L' U L D`
-
-We take advantage of the open FR slot. The corner we want to insert is already on the U layer. So we can do `D'` to move the spot that it belongs to into the open FR slot. Then `L' U L` to insert the corner into FR, and `D` to undo the first D move.
-
-## Other cases
-
-After going through LS, you could then check the cases where one of the pieces is in the U layer, and the other in the F2L slots. A lot of these cases are also easy (just 2 RU/LU triggers), although some might have really strange solutions, like the infamous example being `R' F2 R F2`.
-
-
-
-So the only cases left are the ones with both pieces in the F2L slots, what about those? Bar a few good cases, it's not recommended to learn them. Why? Because when these cases appear in a solve, there's a very high chance that there will be another F2L pair on the cube that's more efficient and faster to solve, so we could just choose that pair instead. This is called [Pair Choice](/improvement-guide/zzf2l/pair-choice).
diff --git a/pages/en/improvement-guide/zzf2l/zzf2l-full-guide.mdx b/pages/en/improvement-guide/zzf2l/zzf2l-full-guide.mdx
deleted file mode 100644
index 3e13eca..0000000
--- a/pages/en/improvement-guide/zzf2l/zzf2l-full-guide.mdx
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: ZZF2L Full Guide
-description: The complete guide to improving your ZZF2L.
-author: yoruba
----
-
-import { Steps } from "nextra/components";
-
-The road to improving your ZZF2L can be daunting. There are many topics to learn, which can seem like a maze to navigate. No worries, this guide will give you a step-by-step order to go from beginner to master in ZZF2L.
-
-
-
-### Learn [intuitive F2L](/tutorial/zzf2l)
-
-Continue until you can do it comfortably.
-
-### Improve your [pair solutions](/improvement-guide/zzf2l/pair-solutions)
-
-Learn good solutions for Last Slot, and F2L cases with at least 1 piece in U. Also learn keyhole and solutions with free slots.
-
-### Drill pair solutions
-
-Drill them into your muscle memory with good turning. That is, you can spot the pieces of an F2L pair, and then be able to solve the pair blindfolded/with eyes closed. You can do that without thinking about the solution, and with 100% confidence that they will be solved. This might take a few weeks or 1-2 months, depending on how much and how consistently you practice. Go to the next step once you have done that.
-
-### Develop your F2L Instinct
-
-Learn these skills together:
-
-- ['Tracking' lookahead](/improvement-guide/zzf2l/lookahead#how-to-start-tracking).
-- Improve [pair choice](/improvement-guide/zzf2l/pair-choice) to prevent 'tunnel vision'.
-- [Deduction](/improvement-guide/zzf2l/deduction).
-
-Do untimed solves for practicing pair choice and deduction. Then, practice the lookahead drill at a slower speed for warm up, and then train your lookahead at a more challenging speed.
-
-### Learn ['Knowing' lookahead](/improvement-guide/zzf2l/lookahead#from-tracking-to-knowing)
-
-Continue doing the lookahead drill from 'Tracking' and apply the techniques there to accelerate the process.
-
-Once you achieve that, focus on turning as fast as possible in F2L. Aim for 10 TPS (turns per second). Do solves where you only time your F2L and aim for 2.8 seconds or lower. F2L at that time is equivalent to the level of a low-mid 6s ZZer. If you have achieved 'Knowing' lookahead and applied all the previous techniques, that would only require good turning (which I assume you have already developed). Proceed if you have achieved that benchmark.
-
-### Learn [multislotting](/improvement-guide/zzf2l/multislotting)
-
-This is the final step for optimizing efficiency. Implement influencing, pseudoslotting and learn algorithms for bad Last Two Pairs cases. After this, your ZZF2L should be under 26 moves on average.
-
-Apply these to your solves and continue timing F2L. This time, aim for 12 TPS, which comes out to be 2.1-2.3 seconds depending on efficiency. This is the equivalent of a skill level for a high 4 - low 5 solver. You can push to 13 TPS, then assuming 26 move efficiency we have 2-second F2L, or a level of mid-4 solving. We can continue pushing, but the limit is going to be somewhere around the skill level of very high 3 to low 4. In my opinion, this is possible.
-
-
diff --git a/pages/en/index.mdx b/pages/en/index.mdx
index ec39b5f..acee686 100644
--- a/pages/en/index.mdx
+++ b/pages/en/index.mdx
@@ -1,60 +1,25 @@
---
-title: Introduction to ZZ
-description: An introduction to the ZZ Method for the Rubik's Cube.
-author: crystalcuber
+title: CubingMethods.com
+description: The best place to learn the Rubik's Cube and how to speedsolve it!
---
-Welcome to ZZMethod.com! Learn the fundamentals of modern ZZ.
-
-## What is ZZ?
-
-ZZ is a speedsolving method for the 3x3 Rubik's Cube. Its most distinctive feature is Edge Orientation (EO): twisting the edge pieces at the start to streamline the rest of the solve.
-
-There are three steps:
-
-1. [**EOCross**](/tutorial/eocross): solve EO and a cross at the same time. An alternative is EOLine.
-2. [**ZZF2L**](/tutorial/zzf2l): complete the First 2 Layers with R, U, L and D turns. No cube rotations required.
-3. [**Last Layer**](/tutorial/ll): solve the top layer with a reduced number of cases.
-
-Yoruba achieved an average movecount of [55.42 STM](/example-solves/yoruba-7.19-ao50) using ZZ.
-He estimates the average movecount of ZZ to be 53.5 moves.
-
-### Step 1: EOCross
-
-Solve two properties in the same step:
-
-- solve Edge Orientation: twist the edges so that they are all solvable without F or B moves.
-- solve the cross: the 4 bottom edges, just like CFOP and many beginner methods.
-
-The EO step slows down the beginning of the solve, in return for benefits in the rest of the solve. It also requires more planning and inspection than CFOP cross or Roux FB.
-
-Alternatively, you can solve EOLine (solve EO plus the bottom-front and bottom-back edges). This results in a more efficient ZZF2L, and it is well suited for one-handed solving. However, the two-handed turning speed in this type of ZZF2L is slower. We recommend using EOCross for two-handed solving.
-
-### Step 2: ZZF2L
-
-Complete the First 2 Layers by solving pairs of matching corners and edges together.
-
-Because EO is solved, only R, U, L and D moves are needed. This increases turning speed because the solver can turn in a streamlined way (we call this the "ergonomics" of a step). No cube rotations are required.
-
-If EOCross is solved, ZZF2L is similar to CFOP F2L but with fewer cases, and it is highly ergonomic. If EOLine is solved, ZZF2L is very unique, using mostly R, U and L moves to form blocks of solved pieces in an efficient way. However, it is not as ergonomic because regrips are more frequent.
-
-### Step 3: LL
-
-Solve the remaining Last Layer with algorithms. Solved EO reduces the number of cases significantly, making the 2-step approach easier to learn and the fastest (1-step) approach feasible to learn.
-
-There are two main options:
-
-- OCLL+PLL: learn 7+21=28 algorithms to solve the last layer in 2 steps.
- - Without EO solved, there would be 57+21=78 algorithms (OLL+PLL).
-- ZBLL: learn 493 algorithms to solve the last layer in 1 step. This is the fastest approach and takes full advantage of ZZ.
- - Without EO solved, there would be 3916 algorithms (1LLL).
-
-## History
-
-ZZ was proposed and developed by several people in an interesting turn of events.
-It's named after Zbigniew Zborowski, who developed and popularized the method in 2006.
-He based the method on the EOLine concept, which was first explored by Gilles Roux and Adam Géhin.
-Check out Athefre's [Cubing History](https://www.cubinghistory.com/3x3/Methods/Zz) for more details about the method's origin.
-
-## Terms of Use
-The contents of this site shall not be used to train or develop generative AI models.
+import { Callout, Cards } from "nextra/components"
+
+
+This site is under construction! We're working on the Roux section first.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/pages/en/method-dev/_meta.tsx b/pages/en/method-dev/_meta.tsx
new file mode 100644
index 0000000..c8f88f7
--- /dev/null
+++ b/pages/en/method-dev/_meta.tsx
@@ -0,0 +1,4 @@
+export default {
+ index: "Introduction to Method Development",
+ "method-dev-life-cycle": "Method Development Life Cycle",
+};
diff --git a/pages/en/method-dev/index.mdx b/pages/en/method-dev/index.mdx
new file mode 100644
index 0000000..f87f5c1
--- /dev/null
+++ b/pages/en/method-dev/index.mdx
@@ -0,0 +1 @@
+# TODO
\ No newline at end of file
diff --git a/pages/en/method-dev/method-dev-life-cycle.mdx b/pages/en/method-dev/method-dev-life-cycle.mdx
new file mode 100644
index 0000000..c9e46e8
--- /dev/null
+++ b/pages/en/method-dev/method-dev-life-cycle.mdx
@@ -0,0 +1,113 @@
+---
+title: Method Development Life Cycle
+description: Metohd development guide for Rubik's Cube and other puzzles.
+author: James Straughan
+---
+
+import Image from "next/image";
+
+
+
+## Introduction
+
+Method development is the design of a method that solves a puzzle while adhering to human limitations or other goals. If humans were able to memorize algorithms for all 43 quintillion states, immediately recall the algorithm associated with the current scramble, and quickly execute the algorithm, there would be no need to design methods for speedsolving. Because we are imperfect, we have to find ways of solving that fit our abilities and our limitations.
+
+Method development can often feel like trying to develop a perpetual motion machine. There is always a balance that occurs. Move count, ergonomics, recognition, and other aspects have their own tradeoffs. Reducing the move count of a method can come at the cost of a higher number of algorithms or difficulty in thinking quickly enough to apply a particular technique. A focus on ergonomics may increase the overall move count. Achieving the right balance, as well as finding a unique set of steps, is what constitutes the art of method development.
+
+How can you create your own quality method? Currently there isn't a definitive list of steps to follow that will guarantee the development of a good method. Being able to create something that is both original and speedsolving capable comes with a lot of experience. It is likely that the first ideas you have will already exist and have probably been considered by many other people. Or, your first method may contain disadvantages that outweigh its advantages. Even getting really fast with a method and relying on that experience wouldn't provide the knowledge of what makes up a good method. Speedsolving skills can potentially provide some of the nuances of algorithm quality kowledge, look ahead, and other traits. But it takes actual development experience and or studying various methods to be able to incorporate all aspects of development to create a quality method.
+
+In an attempt to help you be successful, a guide is provided in the form of a method development life cycle. This guide will step you through the process of finding an original idea, developing the idea into a method, and promoting and maintaining the method to ensure that it remains up to date. With enough practice designing methods, you should be able to develop an intuition for problem solving and the ability to filter out bad ideas.
+
+## Ideation
+
+Every method starts with an idea. The idea can be a method that has a specific shape, to create a certain style of method, or to solve an existing problem. How do you think of a new idea? The best place to start is by looking at existing methods. Maybe a new method shape can be derived from one of them. Or maybe one of the methods has a flaw that can be removed by reworking the steps of the method. Sometimes, but very rarely, randomly combining two methods together can lead to something new. Often the result of these combinations is a method that is less than the sum of its parts. But from this basic idea it may be possible to refine the method into something more viable.
+
+In the beginning it will be easiest to think of a new method shape idea and base your method around that. But when trying to create a method that is genuinely new and competitive, try not to let that be your focus. Most of the possible method shapes and their continuations to the end of the solve have been almost completely explored. Almost every method is simply another order of solving 12 edges, eight corners, and six centers. Thom Barlow, the developer of the K4 method among other developments, once said “The state of method development at the moment is such that any sufficiently thought-out method of the form of solving groups of permutation and orientation in a variety of ways can perform as well as its brethren with minor positives and negatives depending on changes, until something more abstract comes out.”
+
+If you want to create something that is truly unique or has a higher chance of being a better method than the methods that are currently perceived to be top methods, more has to be done than just solving the various pieces in a different order. Try to solve a major problem in a method or method development itself, or create a new concept. As an example, the method named “42” uses conjugation to produce a method that has a very low move count and close to 15 times fewer required algorithms to memorize than if the technique wasn't used. There is also the method named “CEOR” that permutes all of the corners into a specific orbit at the start of the solve. This sets up the cube to be able to be solved using turns of just the upper layer, the right-side layer, and the middle layer adjacent to it. The result is a method that is comfortable for one-handed solving use. New concepts such as these have the potential to change what everyone thought were the limits of speedsolving. To emphasize the importance of focusing on new concepts, Joseph Briggs, developer of the methods 42 and SSC, put a twist on one of Arthur C. Clarke's three laws by stating "Any method distinguishable from magic is insufficiently advanced."
+
+Once the idea or goal is set, it is important to perform research. The idea may have already been developed or the problem that was identified may already have a solution. Be careful not to develop something that someone else has already put work into creating. Method duplication has occurred numerous times in the puzzle community due to the lack of thorough research before starting development. Research the various methods to determine if your idea has already been developed or mentioned by someone else. Below are some resources for researching methods.
+
+- **[SpeedSolving.com](https://www.speedsolving.com/):** SpeedSolving.com has a dedicated Wiki containing a large selection of method pages. In addition, the website and forum was created in 2006 so there have been many discussions on method ideas. Most notably, [The New Method / Substep / Concept Idea Thread](https://www.speedsolving.com/threads/the-new-method-substep-concept-idea-thread.40975/) contains thousands of posts consisting of method ideas and discussions.
+- **[Cubing History](https://www.cubinghistory.com/):** This website provides the history of various methods and techniques. You can use this resource not only to learn about the history of existing methods, but also to see the thought process behind the development of each method. Seeing how someone else formulated an idea and refined it into a successful method may help you develop your own thought processes.
+- **Discord:** There are several servers on Discord dedicated to discussions on individual methods and methods in general. You can join these servers to discuss ideas to determine if they exist, receive feedback on an idea, or collaborate on development. Below are a couple of the most useful servers.
+ - **[Method Development](https://discord.gg/xtZaubNkzg):** This is a dedicated method development server for all puzzles. Within the server, there is also a chennel that links to servers for many individual methods.
+ - **[Straughan's Development Server](https://discord.gg/GJB2ER2Q3M):** A server focusing on the developments of James Straughan as well as general method development discussions.
+
+A final note is that there are some commonly proposed methods that don't always contain their own pages on a wiki or other websites. Below are some commonly invented methods to be aware of.
+
+- **Belt:** This may be the most re-invented method, outside of Corners First, Edges First, and Layer By Layer. The general steps are to solve the edges of the E layer then complete the rest of the cube.
+- **RouxFOP:** When experimenting with Roux and CFOP, you may have the idea to combine the two methods. The steps would be to solve the two 1x2x3 blocks as in Roux, add the bottom layer edges, then orient and permute the last layer as in CFOP. This method is frequently suggested by those new to solving. The problem is that this combination method doesn't take advantage of the strengths of the Roux method, which are its low move count and ergonomics. It also doesn't have the same quality of look ahead for solving the first two layers as CFOP.
+- **ZBRoux:** Taking RouxFOP further, you can combine Roux and ZZ. The idea here is to solve the two 1x2x3 blocks as in Roux, orient the last layer edges while solving the bottom layer edges, then solve the last layer using a single algorithm.
+- **Non-EO Petrus:** Another common idea is to use the Petrus method's idea of continually blockbuilding as far as possible, but omitting or moving edge orientation to a later stage. The commonly proposed steps are to solve a 2x2x3 block, add a 1x2x2 block to the first two layers, solve the last corner and edge pair of the first two layers, then solve the last layer.
+
+## Design
+
+Once you have determined your idea or goal, it is time to plan the steps. In the Design phase, the various possibilities are considered and compared against each other. It isn't always the case that the first idea that comes to mind for the steps of a method will be the best one possible. Continue considering every possible step and variant. This will aid you in discovering the optimal variant for the method that you are designing. In addition to considering your own ideas, look to other methods to see if steps from those can be adapted. It may turn out that one or two steps of another method will be the best variant for your own method. Or maybe you will hit on a great new idea that hasn't yet been proposed or developed for any existing method.
+
+If you are starting from a basic method shape, try to think of many possible continuations. Maybe you can start by solving the remaining corners then solve the last few edges in some way. Or you can complete the first two layers and have a layer to solve in the end. Or, possibly something more abstract will turn out to be the most natural fit for your starting shape and may also make for something unique. If instead you are focusing on solving a problem inherent with an existing method, determine exactly why it is a problem. Knowing why it is a flaw is the first step toward finding a solution. Maybe the solution will be to solve more pieces at once in a step, or to solve a couple of steps in a different order, or it may even be that the method needs to be completely deconstructed and rebuilt into something new. To use the APB method as an example, the idea was that the edge orientation step of the Petrus method is a bottleneck slowing progress of the solve. When trying to find a better continuation for the method, it was decided to reduce the number of edges involved in the orientation step and reduce blindspots by solving additional pieces along with the 2x2x3 block.
+
+Try to find a balance to the number of algorithms and the move count. It is possible to design a method with an extremely low move count, but it may require the user to memorize and practice hundreds of algorithms. Methods such as these can turn out to be advanced and potentially useful in the future, but it is much more likely that the method will be of the same or lower quality than other methods while also requiring much more effort to use. Also try to avoid designing a method that could be viewed as derivative. There is nothing wrong with creating a new method that starts as just another way of solving the first two layers, for example. However, there are already existing ways of reaching that state that have been proven to be very effective. The chance is low that a different set of steps will measure up and it would be a very competitive space to attempt to occupy.
+
+## Analysis
+
+Coming from the Design phase you should have a variant or a method that you have worked out. Before starting development, it is essential to analyze every aspect of the method. You have to answer the basic question “Is my idea good?” Below are some things that are important to cover.
+
+- Are the intuitive steps easy to perform? Low effort means less time spent practicing to become proficient and a better trajectory towards achieving fast solving times.
+- Calculate the average move count of the method. A low move count isn't necessarily evidence that your method is of high quality, but a high move count has the potential to exclude a method from any high level conversations. For the currently popular methods, the move counts average around 45-55 moves. If your method contains some steps that exist in other methods, the average move count for those steps may already be known and available to use. For steps that are more unique where the move count isn't known, you can practice solving the method many times for intuitive steps to find an average move count or use algorithm generator programs for algorithm-based steps.
+- Count the number of algorithms that the user of the method will be required to memorize. Compared to other methods, does your method contain more algorithms? If so, are there benefits to your method that make it worth it to learn the algorithms?
+- Generate the algorithms for each step of your method. Test these algorithms to determine the ergonomics and length. Are the algorithms comfortable to perform? Do they have an acceptable move count average? If the algorithms aren't of high quality, that will have a major impact on the viability of the method.
+- Test the recognition for each step. It is crucial that knowing what to do in each step is quick and easy to see. If a non-intuitive step takes a lot of time to recognize, that is additional time added to the solve.
+- Ask the community for feedback. Others may have input that will help you either improve the method or help you realize that maybe the idea isn't as good as hoped or can be reworked.
+
+During the analysis process, pay attention to the voice in your head that is telling you whether the idea is good or not. If the idea turns out to be not good, that answer can be difficult to accept. Especially if you developed an emotional attachment to the idea. But don't be afraid to throw an idea away. If it is unique and your absolute goal was to create something unique then that's ok. But if your goal is to create something that is competitive for speedsolving, either develop the idea with the caveat that it will only be intended as something fun to use or move on to a new idea. Or, try to go back to the Design phase and consider other possibilities. Keep drilling down until you can perfect a method.
+
+## Development
+
+Now that you have settled on a method that you have deemed worthy of being developed, the development process can be started. Development is the longest phase of the life cycle. Every aspect of the method is created and assembled into a finished product. Simply putting the idea out there often isn't enough. If the development phase is skipped, the idea risks becoming forgotten and later, rightfully so, credited to the proposer who independently had the idea and also put in the work to fully develop it.
+
+The majority of development is often generating all of the algorithms for each of the non-intuitive steps and putting together the resources. There are several computer programs available for this process. Two of the most useful are CubeExplorer, which is useful for quickly generating individual cases with various move sets, and Batch Solver, which has the functionality of generating all of the algorithms at once for a step. During the algorithm generation process, place them into a document so that users have a reference from which to learn. Ensure that each algorithm is accompanied by images showing the case that the algorithm solves. Spreadsheet programs are most commonly used as a way to present algorithms. Alongside the algorithm generation process, decide on a way to recognize the cases for the step. That is, determine at which locations on the cube the user should look and what kinds of patterns reveal each case.
+
+For the intuitive steps, develop strategies for efficiently solving them. Strategies have evolved a lot over time and there are many existing methods that you can look to for learning what works well. For any steps in your method that are already part of another method, it's likely that there are resources available. These can be referenced to shorten the development process or used as a basis upon which to build and add your own techniques.
+
+A cube with good performance is also very useful in the Development phase. When you have a cube that has a good turning capability, it will allow for quick and easy testing of any algorithms that may be included in the method that is being developed.
+
+When the method has been fully developed, decide on your form of presentation. To keep it simple, you can present links to the various documents covering the algorithms and techniques. Or, you can compile everything into a single document that describes the steps of the method and includes the algorithms. To take it a step further, you can create a website for the method and also film videos. These kinds of resources are attractive and project a sense of confidence in the method. Great resources are a major part in developing a community around a method.
+
+There are many tools available for development. Below are some of the most useful.
+
+- **[CubeExplorer](https://kociemba.org/cube.htm) and [Batch Solver](https://trangium.github.io/BatchSolver/):** These are two of the best tools for generating algorithms. CubeExplorer is a great program for quickly generating a single algorithm using a variety of move groups. Batch Solver is useful for generating a group of algorithms for a desired step. Batch Solver provides many features and there is a [video guide](https://www.youtube.com/watch?v=kSXFzK85Q8I) for its use created by Ryan Hudgens.
+- **[Movecount Coefficient Calculator](https://trangium.github.io/MovecountCoefficient/):** A great program for testing algorithm quality. Input a list of algorithms and it will rank them according to their quality as performed by humans. It isn't perfect, but provides a good ranking of algorithms to aid in choosing the ones best for speedsolving.
+- **Spreadsheet software:** Google Sheets is a popular way of presenting the algorithms for each step of a method.
+- **[VisualCube](https://cube.rider.biz/visualcube.php):** Great for creating images. Images for the individual algorithms can be personally made if desired. However, VisualCube makes the process very easy. After an algorithm is input, the image is automatically generated. Individual stickers can be altered, arrows can be drawn, and many other features are included. It can even be combined with spreadsheet formulas to mass generate images for an entire list of algorithms.
+- **[Twizzle.net](https://alpha.twizzle.net/edit/):** This website is useful for creating example solves to demonstrate the steps of a method. It can also be helfpful for visualizing the effects of a sequence of moves.
+- **Algorithm databases and existing algorithm spreadsheets:** Databases such as [speedcubedb.com](https://speedcubedb.com/) can be used as a source if a step in the method is the same as that of another method. If the existing algorithms are good, they can be repurposed. If they aren't good, then it is best to re-generate the algorithms so that your method can be at its best.
+
+## Publication
+
+With development of the method completed, the next step is to put it out into the community. There are many ways that this can be done, including posting on message boards, social media groups, other social platforms, or a promotional video. Promotion is a major part of the development life cycle. It is what ensures that a method becomes known and spreads throughout the community. The more people who know about the method, the more who will try it out.
+
+Be honest in your presentation and provide a list of advantages and disadvantages. Don't exaggerate the positives and downplay the negatives. It may be tempting to claim that your method contains incredible ergonomics, effortless recognition, and an extraordinarily low move count. But all of your positives should be backed up by evidence that should have been obtained in the Analysis and Development phases. There are programs available that can determine the optimal move count that a computer is able to achieve. Humans aren't as capable as these computer solutions. It is best to rely on general numbers that you or other people have been able to achieve in the past for the same or similar steps and also the actual numbers from the algorithm steps that you developed. Honesty in your presentation will greatly help you and your method's long-term reputation.
+
+If the community thinks that the method has potential they will take notice. Sometimes it may take more time and effort to convince others of the advantages of a new method. Some methods contain new concepts or types of steps that are unfamiliar to others. Such new developments can initially be difficult to understand, so come prepared in your presentation. Think of the types of questions that everyone may ask and try to explain each step with the right balance of detail and simplicity. There aren't many methods that hold popularity and most people are focused on practicing solves and becoming fast with their already chosen method instead of paying attention to the latest developments. This means that, even with a decent amount of promotion effort, it may take time for a method to become well-known.
+
+## Maintenance
+
+Even after the method has been released to the public and has gone through the initial testing to be settled into its basic form, development isn't complete. Method development is an ongoing process and there is always more that can be done. Maintenance efforts continue the momentum of the method's growth in popularity and users.
+
+Maintenance involves updating algorithms as better ones are found, adding any new viable advancements or variants, and generally improving upon any weak points. As new finger tricks are found, better puzzle hardware is introduced, and the number of users of the method grows, algorithm sets will change. New and better resources should also be created. It doesn't stop at the basic documents describing the method and listing the algorithms. Tutorials, whether written or in video form, will go a long way toward attracting new users. Maintenance isn't always left up to the creator of the method. With a large enough user base, maintaining the method becomes a community effort. Piece by piece the method is continually refined.
+
+Inevitably the community will provide their opinion of the method. Be willing to listen to the critiques and update your method based on this feedback. People have experience in various areas of development or in solving. Their perspectives can help shape the method into something even better than you originally intended or considered. Other people can potentially give ideas for new and better variants, more ergonomic algorithms, and easier step recognition strategies. From the feedback that you receive, improve your method so that it has a better chance of gaining users. Continue this maintenance and hopefully your method will become popular.
+
+## The Future of Methods
+
+What's next for method development? Many speedsolving-oriented methods eventually merge one or more of its steps for efficiency, ergonomics, and other reasons. Additionally, methods tend to borrow techniques from other methods. CFOP users have integrated the blockbuilding and edge orientation techniques established by the Petrus method. Other methods have used and improved upon the more algorithm-based nature of CFOP. It is also interesting to consider that all modern speedsolving methods have a relatively similar average move count. The average move count is also over double that of what has been proven to be possible through computer analysis of scrambles. In practice and in competitions, solving has become a race to the bottom to execute 45 to 60 turns as quickly as possible.
+
+With methods seemingly converging in several ways and the performance potential among them being similar, it may be time for a new line of thinking. Current methods largely follow a thought process of solving individual or groups of pieces step by step until the solved state is achieved. The final pieces to be solved sit around or within groups of already solved pieces. This means that turning movement is blocked and that the steps to solve the final pieces have to work within the restrictions caused by those previously solved pieces. In order to solve the final pieces, what was solved in previous steps must be broken to allow for freedom of movement for the unsolved pieces, then restored after solving those pieces. Solving in this way is like painting yourself into a corner, trekking across your work because you have no other choice, then fixing your mistakes afterward.
+
+If a computer-generated solution to a scramble is examined, it appears to be a series of random turns until the cube is magically solved on the final turn. Yet, each turn is the result of a total awareness of every piece of the cube. All pieces are interconnected like a hive mind and are working together toward a common goal: the solved state. There may be revolutionary techniques that remain to be discovered. Or existing techniques that can be applied more broadly. The use of a new solving approach may preserve all of the important elements such as ergonomics, recognition, and look ahead, while bringing speedsolving closer to the mystifying move optimal solutions.
diff --git a/pages/en/roux/_meta.tsx b/pages/en/roux/_meta.tsx
new file mode 100644
index 0000000..7cc1b48
--- /dev/null
+++ b/pages/en/roux/_meta.tsx
@@ -0,0 +1,6 @@
+export default {
+ index: "Introduction",
+ tutorial: "Roux Tutorial",
+ // "improvement-guide": "How to Improve",
+ // "example-solves": "Roux Example Solve Library",
+};
diff --git a/pages/en/roux/example-solves.mdx b/pages/en/roux/example-solves.mdx
new file mode 100644
index 0000000..1333ed7
--- /dev/null
+++ b/pages/en/roux/example-solves.mdx
@@ -0,0 +1 @@
+TODO
diff --git a/pages/en/roux/improvement-guide.mdx b/pages/en/roux/improvement-guide.mdx
new file mode 100644
index 0000000..30404ce
--- /dev/null
+++ b/pages/en/roux/improvement-guide.mdx
@@ -0,0 +1 @@
+TODO
\ No newline at end of file
diff --git a/pages/en/roux/index.mdx b/pages/en/roux/index.mdx
new file mode 100644
index 0000000..aa8bde7
--- /dev/null
+++ b/pages/en/roux/index.mdx
@@ -0,0 +1,91 @@
+---
+title: Roux Method Introduction
+description: An introduction to the Roux Method for the Rubik's Cube.
+author: crystalcuber
+---
+
+import Link from "next/link";
+import { Steps } from 'nextra/components'
+import TwistyPlayer from "components/TwistyPlayer";
+import { STICKERINGS } from "lib"
+import YouTubeEmbed from "components/YouTubeEmbed";
+
+
+## What is Roux?
+
+Roux (pronounced "roo") is a fast and intuitive method for solving the Rubik's Cube. [Proposed by Gilles Roux in 2003](https://www.cubinghistory.com/3x3/Methods/Roux), it works by simplifying the cube into an easier puzzle with fewer types of moves.
+
+These are the four main steps of Roux:
+
+
+ ### First Block (FB)
+
+
+ Build a 1x2x3 block on one side of the cube. This is done by joining pieces together with logic, no algorithms needed.
+
+
+ ### Second Block (SB)
+
+
+ Build another 1x2x3 block on the opposite side.
+
+
+ ### Corners of the Last Layer (CMLL)
+
+
+ Solve the four corners on the top side with an algorithm set called CMLL.
+
+
+ ### Solve the Last Six Edges (LSE)
+
+
+
+ Solve the remaining 6 edges and 4 centers of the cube.
+ This is all done with M and U layer moves.
+
+
+
+
+## Why learn Roux?
+
+Roux is a **fast** speedsolving method used to achieve incredible results in official competitions. Check out Crimson Arradaza's 6.05 3x3 average with Roux:
+
+
+
+Roux is an excellent method for one-handed solving. Sean Patrick Villanueva used Roux to set his 8.09 World Record average in May of 2024.
+
+
+
+Roux is also very **intuitive**. It encourages solving the cube with a natural thought process. It's easy to learn and doesn't require memorizing many algorithms.
+
+## Get started with Roux
+
+Check out our [Roux Tutorial](/roux/tutorial)!
diff --git a/pages/en/roux/tutorial.mdx b/pages/en/roux/tutorial.mdx
new file mode 100644
index 0000000..f336a1f
--- /dev/null
+++ b/pages/en/roux/tutorial.mdx
@@ -0,0 +1,19 @@
+---
+title: Roux Tutorial
+description: The complete beginners' guide to the Roux method.
+author: crystalcuber
+---
+
+{/* TODO: make this look better */}
+
+import { LinkButton } from "components/LinkButton"
+
+Welcome to to the Roux tutorial for solving the Rubik's Cube!
+It features visual, beginner-friendly guides for each step of the method:
+
+1. [First Block (FB)](/roux/tutorial/fb)
+2. [Second Block (SB)](/roux/tutorial/sb)
+3. [Corners of the Last Layer (CMLL)](/roux/tutorial/cmll)
+4. [Last Six Edges (LSE)](/roux/tutorial/lse)
+
+[Start here!](/roux/tutorial/fb)
diff --git a/pages/en/roux/tutorial/_meta.tsx b/pages/en/roux/tutorial/_meta.tsx
new file mode 100644
index 0000000..f7fbc4c
--- /dev/null
+++ b/pages/en/roux/tutorial/_meta.tsx
@@ -0,0 +1,6 @@
+export default {
+ fb: "First Block (FB)",
+ sb: "Second Block (SB)",
+ cmll: "Corners of the Last Layer (CMLL)",
+ lse: "Last Six Edges (LSE)",
+};
diff --git a/pages/en/roux/tutorial/cmll.mdx b/pages/en/roux/tutorial/cmll.mdx
new file mode 100644
index 0000000..e69de29
diff --git a/pages/en/roux/tutorial/fb.mdx b/pages/en/roux/tutorial/fb.mdx
new file mode 100644
index 0000000..ab22a60
--- /dev/null
+++ b/pages/en/roux/tutorial/fb.mdx
@@ -0,0 +1,6 @@
+---
+title: First Block (FB)
+description: Learn First Block, the first step of the Roux Method.
+author: crystalcuber
+---
+
diff --git a/pages/en/roux/tutorial/lse.mdx b/pages/en/roux/tutorial/lse.mdx
new file mode 100644
index 0000000..e69de29
diff --git a/pages/en/roux/tutorial/sb.mdx b/pages/en/roux/tutorial/sb.mdx
new file mode 100644
index 0000000..e69de29
diff --git a/pages/en/tutorial/eo.mdx b/pages/en/tutorial/eo.mdx
deleted file mode 100644
index fb8535e..0000000
--- a/pages/en/tutorial/eo.mdx
+++ /dev/null
@@ -1,434 +0,0 @@
----
-title: Edge Orientation (EO)
-description: Learn EO, the foundation of the ZZ Method.
-author: crystalcuber
----
-
-import YouTubeEmbed from "components/YouTubeEmbed";
-import CubeMp4Embed from "components/CubeMp4Embed";
-import TwistyPlayer from "components/TwistyPlayer";
-import { Callout } from "nextra/components";
-
-Here's a video! Below is the written version with interactive cubes.
-
-
-
-## Introduction
-
-**Edge Orientation (EO)** is the way edge pieces are twisted on the cube. This is the key concept to Step 1.
-
-**"Solving" EO** means twisting the edges in a certain way to make the rest of the solve nicer. It feels like magic!
-
-{/* TODO: add articles that explain the application of EO to CFOP and FMC */}
-
-
- Not only is EO the foundation of ZZ, it's very useful for CFOP and essential
- to FMC!
-
-
-## 1. How EO works
-
-### Natural moves
-
-There are six basic kinds of moves on the cube. R, U, L, D, F and B moves.
-We can split them into two groups:
-
-1. **Natural moves:** All R, U, L, and D moves. Let's call them "natural" because they're fast and comfortable for your hands.
- _Examples: R, D2, L', U_
-
-2. **Unnatural moves:** All F and B moves. Let's call them "unnatural" because they're more awkward (unless in specific hand positions).
- _Examples: F, B', F2_
-
-In a good speedsolving method, we want to use many natural moves and few unnatural moves.
-But that begs the question: can we use _only_ natural moves to solve the whole cube?
-
-Almost! This is the closest we can get, usually something like this:
-
-
-
-With _only_ natural moves, we can solve the corners and move the edges to the right place.
-But the problem is that **natural moves can't twist edges**.
-Some edges could be solved just fine👍, but others remain twisted wrong👎.
-
-There are two ways an edge piece can be twisted, or **"oriented"** on the cube:
-
-- 👍**Good edge:** oriented in a way that's solvable with natural moves. Also known as "oriented".
-- 👎**Bad edge:** oriented in the other way, which is **un**solvable with natural moves. Also known as "misoriented".
-
-### The purpose of EO
-
-The idea of ZZ is to add a step at the beginning of the solve, which will speed up the rest of the solve.
-
-
- Twist all bad edges so they become good edges.
-
-
-This is called **solving EO**, or **orienting the edges**. Then the whole cube can be solved with natural moves
-only! Solving EO eliminates the need for F/B moves or cube rotations, allowing us to turn in a fast and streamlined way.
-
-Plus, EO reduces the number of cases you'll encounter during the solve.
-
-- Unlocks realistic 1-look last layer (ZBLL)
-- Makes 2-look last layer (OCLL+PLL) easier to learn
- {/* TODO: add a link to an article explaining the benefits and tradeoffs of ZZ due to EOStep */}
- {/* Learn more here: */}
-
-### Orbits
-
-Earlier, we discovered that natural moves can't twist edges. Why is that?
-
-When doing R, U, L, D turns on the cube, the edge stickers move in a restricted way.
-(Stickers are the coloured tiles on the cube.)
-
-Here we have a green-red edge. Let's press ▶️ and watch the green sticker, see where it can move.
-
-
-
-The green sticker can only visit the region of spots marked with purple below.
-It can't visit the region of spots marked with light grey. The red sticker is the opposite!
-We call these two regions "orbits".
-
-
-
-The spots marked in purple, let's call it the **purple orbit**.
-It covers all the edge stickers on the **U**p and **D**own sides, plus two on the **F**ront and two on the **B**ack.
-Remember this, it's important later!
-
-The other spots are marked with light grey, and we'll call it the **outer orbit**.
-
-During natural moves, the stickers on one orbit will always stay on that orbit.
-Press ▶️ to see!
-
-
-
-Also notice that every edge has one sticker in the purple orbit, and the other sticker in the outer orbit.
-For example, this bad edge has a red sticker in the purple orbit, and a green sticker in the outer orbit.
-
-
-
-In order to twist this edge, we must switch red and green around.
-But that means red (on the purple orbit) must move to where green was (on the outer orbit), which is impossible with natural moves!
-_That's why natural moves can't twist edges._
-
-This explains why the edge is "bad".
-It's only solvable if we use unnatural moves, which are the only moves that can move stickers between orbits.
-
-
-
-We can do `F' U' R'` to twist the front-right edge.
-The `F'` changed the orientation of the bad edge, making it a good edge solvable with natural moves (`U' R'` in this case).
-
-We call this process **orienting an edge:** turning a bad edge into a good edge with an unnatural move.
-Our goal is to orient all of the edges.
-
-But how can we tell that an edge is bad or good?
-If an edge is in its solved place but twisted wrong, it's definitely bad (natural moves can't twist edges!)
-But what if it were somewhere else? Not as obvious.
-
-In the next section, we'll learn a simple system to detect these bad edges.
-And after that, how we can orient them all.
-
-## 2. Recognizing bad edges
-
-### Perspective
-
-When looking for bad edges around the cube, there is a problem: edge orientation depends on your perspective!
-If you turn the whole cube around, some edges can change from bad to good or good to bad.
-For example, if you do a `y` cube rotation, F moves (unnatural) become L moves (natural).
-So a bad edge that needs to be solved with `F` becomes a good edge that can be solved with `L`.
-
-{/* TODO: add article about applying EO to CFOP, and put a link to it in this callout. */}
-
-
- This is how CFOP orients edges during F2L! If you use CFOP, recognizing EO
- helps eliminate unnecessary `y` rotations.
-
-
-In order to recognize bad edges, we should not turn the cube around.
-For each solve, pick a center to stay at the top, and another to stay at the front.
-
-Now we're ready to recognize bad edges! Follow along with this scramble:
-`F' R' D B U2 R' U R D2 L B2 R L U2 F2 B2 L B2 R'`
-
-When following scrambles, always have the white center at the top, green center at the front.
-After that, we can choose how to hold the cube. For example, orange center top, green center front.
-
-
-
-We have two rules for finding bad edges:
-
-### Rule #1
-
-**Rule #1:** look for **L and R stickers on the purple orbit**. Their edges are bad.
-
-"L and R stickers" means the stickers that match the color of **L**eft and **R**ight centers.
-In our example, we're looking for yellow and white stickers on the purple orbit.
-Edges with those stickers are bad.
-
-
-
-{/* NOTE: invisible character (U+2060) between the emoji for each piece, prevents line break from separating them */}
-
-- On the **U**p side, there's a white sticker so its edge (⬜🟩) is bad.
-- At the **F**ront two spots, there are no whites/yellows.
-- On the **D**own side, there's one white and one yellow so we found two more bad edges (⬜🟦, 🟨🟥).
-- At the **B**ack two spots, there are no whites/yellows.
-
-We found three bad edges so far, let's mark them with tape.
-
-
-
-### Rule #2
-
-**Rule #2:** Look for **U and D stickers on the outer orbit**. Their edges are bad.
-
-In our example, we're looking for orange and red stickers on the outer orbit.
-
-
-
-- On the **L**eft side, there are no oranges/reds.
-- At the **F**ront two spots, there's a red sticker so 🟥🟩 is the 4th bad edge.
-- On the **R**ight side, there's an orange sticker so 🟧🟦 is the 5th bad edge.
- (The red sticker is on an edge we already know is bad.)
-- At the **B**ack two spots, there's an orange sticker so 🟧🟩 is the 6th bad edge.
-
-We've found all 6 bad edges! Here they are.
-
-
-
-
- There will always be an even number of bad edges, from 0 to 12.
-
-
-### The Rules Explained
-
-The rules can seem magical, but this is why they work:
-
-**Rule 1:** L and R stickers on the purple orbit cannot be solved with natural moves, because their solved positions
-are all on the outer orbit. Natural moves can't move stickers between orbits, so those edges are bad.
-
-**Rule 2:** It's the same logic for the U and D stickers.
-
-## 3. Solving EO
-
-Finally we'll learn how to fix these bad edges! Here is our main strategy:
-
-### Strategy: Fix 4 bad edges
-
-`F` or `F'` flips the orientation of all 4 edges on the **F**ront layer. If they are all bad, they become all good.
-Press ▶️ to see! (Bad edges are red, good edges are green)
-
-
-
-That means we can place 4 bad edges on the Front layer with natural moves, do `F`/`F'` and they'll become all good!
-
-Continuing our example:
-
-- We see there's already 2 bad edges at the front.
-- We can do natural `L'` to move a 3rd edge to the front.
-- Then natural `U2` for the 4th edge.
-
-Then there's 4 bad edges at the front, we can do unnatural `F` to orient them.
-
-
-Moves: `L' U2 F`
-
-Great, we've fixed 4 bad edges at once. Before we solve the remaining bad edges, let's master this strategy.
-
-#### Using F2 to place edges
-
-We're using natural moves to place the bad edges on the Front layer because they don't mess up the orientation of edges.
-In addition, we can also use `F2`, it doesn't change edge orientation either!
-`F2` is like doing `F` twice. Flipping the orientation of edges twice is the same as doing nothing.
-
-Here's an example where using _only_ natural moves would be hard:
-
-
-Moves: `U' L U D`
-
-With `F2`, it's much simpler:
-
-
-Moves: `F2 U2`
-
-In summary, we can use natural moves _and_ `F2` to move edges around without affecting EO.
-
-#### Placing bad edges at the back
-
-Everything we've learned about the Front layer works for the Back layer too!
-
-`B` and `B'` flip the orientation of all 4 edges on the **B**ack layer.
-So we can also place 4 bad edges on the Back and do a `B` or `B'` to fix 4 bad edges.
-This is useful when there are already more bad edges at the Back than the Front.
-
-`B2` also doesn't affect EO, so we can move edges around with B2 as well.
-
-#### Summary
-
-**To fix 4 bad edges at once:**
-
-1. Use _natural moves, `F2` and `B2`_ to collect 4 edges on the Front or Back.
-2. Then do `F`/`F'` or `B`/`B'` to orient them.
-
-Repeat this strategy, fixing 4 bad edges each time.
-We'll either orient them all, or there will be 2 leftover bad edges.
-In our example, we have 2 leftovers. We need a strategy for that!
-
-### Strategy: Add 2 bad edges
-
-There's no way to directly orient 2 edges, so our strategy is to _add_ 2 more bad edges to get 4 total.
-Then we can use the previous strategy to orient the 4 edges.
-
-The idea: place exactly 1 bad edge on the Front or Back, and flip with `F`/`F'` or `B`/`B'`. 2 new bad edges will appear.
-
-
-
-Let's try that on our example.
-There's already exactly 1 bad edge placed at the Back, so we can do `B` to make two more edges.
-
-
-Moves: `B`
-
-Now we have 4 bad edges, so we can use the strategy from before to fix them.
-
-
-Moves: `R' B`
-
-Now EO is solved, congrats! 🎉 You've learned the fundamental concept of ZZ.
-Here are some tips and tricks to help you get started with EO.
-
-## 4. Tips & tricks
-
-### Keeping track of bad edges
-
-In this tutorial, we've marked the bad edges with tape to keep track of them.
-But in your own solves, it can be hard at first to remember where the bad edges are.
-
-1. As a start, you can put your fingers on the bad edges.
-
-2. Try drawing imaginary shapes.
- 2 bad edges can make a line, and 3 on the same side can make a triangle.
- That can be a lot easier to remember.
-
-3. If you have more bad edges than good edges, you can track the good edges instead.
- For example, 8 bad edges means there are 4 good edges that you can track instead.
-
-### Strategy for 6 or 10 bad edges
-
-To orient 6 or 10 bad edges we learned to do this:
-
-1. Orient 4 edges (once or twice) to get down to 2 bad edges
-2. Add 2 bad edges to have 4 in total
-3. Orient the 4 edges
-
-Here is a special trick that can simplify your solutions:
-
-1. _Orient 2 edges at the beginning_
-2. Orient 4 edges (once or twice) to get down to 0.
-
-Place exactly 3 bad edges on the Front or Back, and flip with `F`/`F'` or `B`/`B'`.
-2 bad edges will disappear.
-
-
-
-We couldn't use this trick when we had only 2 edges left, because this trick requires at least 3 bad edges.
-That's why it's useful for 6 or 10 bad edges.
-
-### Practice
-
-At the beginning, EO will be hard to do. But it gets much easier with practice.
-You'll be able to recognize bad edges quicker, find solutions more easily and plan more of it during inspection.
-
-## What's next?
-
-**Congrats!** You've learned EO. We suggest doing some untimed EO solves to get more familiar with EO.
-Then you're ready to move onto [EOCross](/tutorial/eocross).
-
-## Bonus EO Example
-
-We have [another EO example solve!](https://www.youtube.com/watch?v=sb0U5OVvIQg)
diff --git a/pages/en/tutorial/zzf2l.mdx b/pages/en/tutorial/zzf2l.mdx
deleted file mode 100644
index 6514f89..0000000
--- a/pages/en/tutorial/zzf2l.mdx
+++ /dev/null
@@ -1,593 +0,0 @@
----
-title: How to solve ZZF2L
-description: Learn ZZF2L, the second step of the ZZ Method.
-author: S1neWav_ and crystalcuber
----
-
-import TwistyPlayer from "components/TwistyPlayer";
-import { Callout } from "nextra/components";
-
-## Introduction
-
-**ZZF2L** is the 2nd step of the ZZ Method.
-After [EOCross](/tutorial/eocross), complete the **First 2 Layers (F2L)** of the cube, which are the bottom two layers.
-
-
-If you use the CFOP method, you already know how to solve F2L.
-
-Transferring CFOP knowledge
-ZZF2L is the same process, except cube rotations and `F`/`B` moves are not
-needed because edges are oriented.
-
-The cases in CFOP that use rotations or `F`/`B` either never occur ZZ, or are solved with [ZZ-specific
-solutions](/improvement-guide/zzf2l/pair-solutions#main-resource-zzf2l-doc)
-that keep the edges oriented.
-
-
-
-
-
-The rest of the article does not require any knowledge of CFOP.
-
-To complete the F2L, we need to solve four corners and four edges around the EOCross.
-
-
-
-Each pair of matching corners and edges is called an **F2L pair**. For example, this is the front-right (FR) pair, scrambled up:
-
-
-
-And that "gap" where a pair belongs to is called an **F2L slot**. So the FR pair belongs to the FR slot, shown above as an empty spot.
-
-We name the four pairs and their four slots by their positions. FR is front-right, FL is front-left, BR is back-right, BL is back-left.
-
-### Basic inserts
-
-Many beginner methods for the Rubik's cube will complete the First 2 Layers, one piece at a time.
-This is easy to learn, but slow for speedsolving.
-Instead, we will learn how to solve _both pieces_ of an F2L pair together, which is much faster.
-
-Let's begin by looking at the two simplest ways to solve a pair together, using the FR pair as an example.
-We call these two simplest ways **basic inserts**.
-
-#### Joined pair
-
-This is the **joined pair:** the two pieces of this F2L pair are joined together with the colors aligned.
-
-
-Moves: `R U' R'`
-
-We can solve joined pairs in three moves with this general strategy (brackets have the moves for just this example):
-
-1. Lift the slot to the top. (`R`)
-2. Move the pair into the slot. (`U'`)
-3. Bring the solved slot back down. (`R'`)
-
-Press ▶️ above to see it in action!
-
-#### Split pair
-
-This is the **split pair:** it looks like a joined pair that was split apart by one move.
-We can also solve this in three moves with this strategy:
-
-
-Moves: `R U R'`
-
-1. Lift the slot to the top, _while also joining the pair_. (`R`)
-2. Move the pair into the slot. (`U`)
-3. Bring the solved slot back down. (`R'`)
-
-### Intuition
-
-F2L solutions make "intuitive" sense: you can see and understand how they work.
-This is powerful because we don't need to memorize these solutions as algorithms (`R U' R'`, `R U R'`...).
-In fact, we shouldn't! You'd have to memorize all the variations for FL, BR and BL too.
-
-If you remember the strategy of a solution, you can easily apply it for all four pair positions.
-Here's the same F2L case on both the FR and FL pairs.
-
-Front-right pair:
-
-
-Moves: `R U2 R'`
-
-Front-left pair:
-
-
-Moves: `L' U2 L`
-
-They're solved with the same strategy, because they're just mirror images of each other.
-It's a good skill to see them as exactly the same thing.
-
-This tutorial will mainly use the FR pair to show strategies, but they work for all pairs.
-
-# How to solve F2L
-
-We'll solve each F2L pair, one at a time.
-There are four steps to solving a pair:
-
-1. Move the pieces to the top layer.
-2. Separate the two pieces if they're touching.
-3. Set up a basic insert.
-4. Do the basic insert.
-
-Since EOCross is solved, we only need to turn the R, U, and L layers.
-No cube rotations are needed, so we will keep holding the cube at the same angle throughout.
-
-## Step 1
-
-We want both pieces of the F2L pair to be in the top layer.
-Any F2L piece that is not in the top layer will be trapped in one of the unsolved F2L slots around the cube.
-
-To move a trapped piece to the top, we'll learn a general strategy.
-As an example, the white-blue-orange corner is trapped in the FR slot.
-
-
-Moves: `R U R'`
-
-1. Move the slot containing the piece to the top, using an R/L-layer move. (`R`)
-2. Free the trapped piece with _any_ U-layer move. (`U`)
-3. Move the slot back down. (`R'`)
-
-This strategy still works if both F2L pieces are trapped in the same slot:
-
-
-Moves: `R U R'`
-
-However, if exactly one piece is already at the top, there's a chance that it will become trapped when we free the other piece!
-For example, doing `R U R'` here will just trap the corner.
-
-
-Moves: `R U R'`. Oh no, corner's trapped now!
-
-To avoid this, we can _wisely_ choose a U-layer move, not just any.
-It should take both pieces out of the first move's layer.
-
-Here, the first move is `R`, so then we move the pieces out of the R layer.
-`U2` works. You could also do `U'`.
-
-
-Moves: `R'`**`U2`**`R'`
-
-This way, the third move has no chance of bringing any pair pieces back down.
-
-
-Another example
-
-This BR pair has both pieces trapped.
-Let's lift the edge to the top.
-
-
-Moves: `L U' L'`
-
-1. It's trapped in the BL slot, so the `L` will move that slot up.
-2. Then `U'` (could be any U-layer move) to free the edge.
-3. Then `L'` to move the BL slot back down.
-
-Then we can lift the corner to the top, but be careful because we now have the edge at the top.
-
-
-Moves: `L' U' L`
-
-1. It's trapped in the FL slot, so the `L'` will move that slot up.
-2. Then `U'` or `U2` to free the corner. The first move is `L'`, so we should move the pieces out of the L layer. `U` does not, and in this case would trap the edge that we just freed.
-3. Then `L` to move the FL slot back down.
-
-
-
-## Step 2
-
-The pair is now at the top, but if they're "touching" then we want to separate them.
-
-The pair is **touching** if they're right next to each other like this:
-
-
-
-This pair is separated, which is what we want:
-
-
-
-To separate a touching pair, there are four easy moves:
-
-1. Move the corner to above an unsolved slot, with a U-layer move. Skip if it's already like that.
-2. Move that unsolved slot to the top using an R/L-layer move.
-3. Do `U2`.
-4. Move the slot back down, which will cut the pair in half.
-
-For example, in this situation we can do:
-
-1. `U` to move the corner to above the unsolved FR slot.
-2. `R` to move the unsolved FR slot to the top.
-3. `U2`.
-4. `R'` to move the FR slot back down.
-
-
-Moves: `U R U2 R'`
-
-
-Another example
-
-Here's the FL pair, the pieces are touching and the BL slot is also unsolved.
-
-
-Moves: `L U2 L'`
-
-1. This step is skipped, the corner is already above an unsolved slot (BL).
-2. We do `L` to lift the BL slot to the top.
-3. Then `U2`.
-4. Then `L'` to bring the BL slot back down, which separates the pair.
-
-
-
-Note: if your pair is touching and is also a [joined pair](/tutorial/zzf2l#joined-pair), then you already have a basic insert ready!
-Skip to [Step 4](/tutorial/zzf2l#step-4).
-
-## Step 3
-
-Now we'll set up the pair for a [basic insert](/tutorial/zzf2l#basic-inserts).
-We can move the pieces around to form a joined pair or a split pair.
-
-There are three types of cases, based on the way the corner is twisted:
-
-### Case A
-
-**Case A:** The "D sticker" faces the top.
-The corner will always have a **D sticker:** a sticker that matches the color of the bottom (D) center.
-We'll setup a joined pair.
-
-Here's the strategy alongside an example:
-
-
-Moves: `U2 R U R'`
-
-1. Align the edge with the center that matches its side color. (`U2`)
-2. Lift the slot we're solving to the top. (`R`)
-3. Do the U-layer move that stacks the corner on top of the edge. (`U`)
-4. Bring the slot back down. (`R'`)
-
-Then we'll have a joined pair.
-
-
-Another example
-
-Here's the FL pair, the corner has the white D sticker on the top side so it's Case A.
-
-
-Moves: `U L U2 L'`
-
-1. We do `U` to line up the edge's orange side sticker with the orange center.
-2. We're solving the FL slot, so `L` to lift the FL slot to the top.
-3. Then `U2` to stack the corner on top of the edge
-4. Finally `L'` to bring the FL slot back down.
-
-
-
-### Case B
-
-**Case B:** the top stickers match.
-The corner is twisted so that the stickers on the top of both pieces are the same color.
-The joined pair is also like that, so we'll set up a joined pair.
-
-To do that, we'll temporarily hide the corner so that we can bring the edge right next to it.
-The **hiding spot** for the corner is the position that is an `R2` or `L2` move away from its solved position.
-
-Here's the strategy for Case B:
-
-
-Moves: `U' R U2 R'`
-
-1. Move the corner to its "hiding spot". (Here it's the back-right, do `U'` to move the corner there)
-2. Lift the slot we're solving to the top which will hide the corner. (`R`)
-3. Move the edge to the front or back, whichever is next to the hiding spot. (Here, move it to the back with `U2`)
-4. Un-hide the corner. (`R'`)
-
-Now we'll have a joined pair!
-
-
-Another example
-
-This is the BL pair. Both pieces have green on the top, so this is Case B.
-
-
-Moves: `L U L'`
-
-Let's find the hiding spot of the corner.
-The corner's solved position is at the bottom-back-left.
-Imagine we did an `L2`. That position would move to the top-front-left.
-That's the hiding spot.
-
-1. The corner is already at the hiding spot. This step is skipped!
-2. We're solving the BL slot, so we do `L` to lift that slot to the top.
-3. We need to move the edge to either the front or the back. The front position is right next to the hiding spot, so we'll move the edge there with `U`.
-4. Then `L'` to bring the BL slot back down.
-
-
-
-### Case C
-
-**Case C:** the top stickers don't match.
-The corner is twisted so that the stickers on the top are different colors.
-It's also not Case A, so we don't see a D sticker at the top.
-The split pair is also like this, so we'll set up to the split pair.
-
-There are only two cases. It's either a split pair which is our goal (you can see that it's 1 move away from being joined).
-
-
-
-Or, it's not a split pair. We'll follow a strategy very similar to Case B.
-
-
-Moves: `U' R U R'`
-
-1. Move the corner to its hiding spot. (`U'`)
-2. Lift the slot we're solving to the top, which will hide the corner. (`R`)
-3. Move the edge to the left or right, whichever is _furthest_ from the hiding spot.
-4. Un-hide the corner. (`R'`)
-
-Now we have a split pair!
-
-
-Another example
-
-Consider this BR pair. The top stickers of the two pieces are red and green.
-They don't match, and we also don't see a D sticker (white) so it's Case C.
-
-We can see they can't be joined together with one move, so this is not the split pair we want yet.
-The corner's solved position is the bottom-back-right.
-Imagine we did an `R2`. That position would move to the top-front-right.
-That's the hiding spot.
-
-
-Moves: `U2 R' U' R`
-
-1. We'll do `U2` to move the corner to the hiding spot (top-front-right).
-2. Then `R'` to lift the BR slot up, which hides our corner.
-3. We need to move the edge to either the left or the right position. The right would be right next to the hiding spot, so we'll move the edge to the left instead with a `U'`.
-4. Then `R` to bring the BR slot back down.
-
-
-
-## Step 4
-
-Finally it's time to solve our joined/split pair. We'll position the pair and then do the basic insert.
-
-### Solving a joined pair
-
-To solve a joined pair, we need to position the pair so that it won't get split by the basic insert.
-The basic insert will be turning the R or L layer, whichever one contains the slot we're solving.
-So we need to move the pair out of that R/L layer, to prevent it from getting split.
-
-For instance, this is a joined FR pair so we're solving the FR slot.
-The FR slot is in the R layer, so we can do a `U2` to move the pair out of the R layer.
-`U'` also works.
-
-
-
-Now it's time to do the basic insert. Here's the explanation from the [basic inserts section](/tutorial/zzf2l#basic-inserts) again:
-
-1. Lift the slot to the top. (`R`)
-2. Move the pair into the slot. (`U'`)
-3. Bring the solved slot back down. (`R'`)
-
-
-Moves: `R U' R'`
-
-Alternatively, if we chose `U'` instead of `U2` to position the pair, our basic insert will be like this:
-
-
-Moves: `R U2 R'`
-
-Exact same strategy, but in step 2 we did a `U2` to move the pair into the slot.
-
-### Solving a split pair
-
-To solve a split pair, we need to position the pair so that it will get joined by the basic insert.
-The corner needs to be above the slot we're solving, and that's the only position that works.
-
-In this case, do a `U'` to move the corner above the FR slot, which the pair belongs to.
-
-
-
-Now it's time to do the basic insert. Here's the explanation from the [basic inserts section](/tutorial/zzf2l#basic-inserts) again:
-
-
-Moves: `R U R'`
-
-1. Lift the slot to the top, _while also joining the pair_. (`R`)
-2. Move the pair into the slot. (`U`)
-3. Bring the solved slot back down. (`R'`)
-
-Now the F2L pair is solved!
-
-## Conclusion
-
-**Congrats!** You've completed the ZZF2L tutorial.
-It may be a lot to take in initially, but because ZZF2L is intuitive it will become second nature.
-There are also a lot of patterns, for example you'll be lifting slots up and putting them back down.
-Solutions are generally alternating between R and U moves, or L and U moves.
-You'll get the hang of it!
-
-The next and final step is [Last Layer](/tutorial/ll).
diff --git a/pages/he/_meta.tsx b/pages/en/zz/_meta.tsx
similarity index 68%
rename from pages/he/_meta.tsx
rename to pages/en/zz/_meta.tsx
index 9c13489..504dc40 100644
--- a/pages/he/_meta.tsx
+++ b/pages/en/zz/_meta.tsx
@@ -7,11 +7,4 @@ export default {
"tutorial": "ZZ Tutorial",
"improvement-guide": "How to Improve",
"example-solves": "ZZ Example Solve Library",
- "blog": {
- "title": "Blog",
- "type": "page",
- "theme": {
- "sidebar": false
- }
- }
}
diff --git a/pages/en/about.mdx b/pages/en/zz/about.mdx
similarity index 100%
rename from pages/en/about.mdx
rename to pages/en/zz/about.mdx
diff --git a/pages/en/example-solves.mdx b/pages/en/zz/example-solves.mdx
similarity index 98%
rename from pages/en/example-solves.mdx
rename to pages/en/zz/example-solves.mdx
index 3857ace..ce66c33 100644
--- a/pages/en/example-solves.mdx
+++ b/pages/en/zz/example-solves.mdx
@@ -5,7 +5,7 @@ author: crystalcuber
---
import { Cards } from "nextra/components";
-import logo from "public/logo.svg";
+import logo from "public/logo-eoline.svg";
import logoEOCross from "public/logo-eocross.svg";
import Image from "next/image";
diff --git a/pages/en/example-solves/_meta.tsx b/pages/en/zz/example-solves/_meta.tsx
similarity index 100%
rename from pages/en/example-solves/_meta.tsx
rename to pages/en/zz/example-solves/_meta.tsx
diff --git a/pages/en/example-solves/gen-11.68-oh-ao5.mdx b/pages/en/zz/example-solves/gen-11.68-oh-ao5.mdx
similarity index 100%
rename from pages/en/example-solves/gen-11.68-oh-ao5.mdx
rename to pages/en/zz/example-solves/gen-11.68-oh-ao5.mdx
diff --git a/pages/en/example-solves/gen-8.99-ao5.mdx b/pages/en/zz/example-solves/gen-8.99-ao5.mdx
similarity index 100%
rename from pages/en/example-solves/gen-8.99-ao5.mdx
rename to pages/en/zz/example-solves/gen-8.99-ao5.mdx
diff --git a/pages/en/example-solves/jouda-11.26-oh-ao5.mdx b/pages/en/zz/example-solves/jouda-11.26-oh-ao5.mdx
similarity index 100%
rename from pages/en/example-solves/jouda-11.26-oh-ao5.mdx
rename to pages/en/zz/example-solves/jouda-11.26-oh-ao5.mdx
diff --git a/pages/en/example-solves/luna-9.00-ao25.mdx b/pages/en/zz/example-solves/luna-9.00-ao25.mdx
similarity index 100%
rename from pages/en/example-solves/luna-9.00-ao25.mdx
rename to pages/en/zz/example-solves/luna-9.00-ao25.mdx
diff --git a/pages/en/example-solves/rouxzzcfop-7.64-ao12.mdx b/pages/en/zz/example-solves/rouxzzcfop-7.64-ao12.mdx
similarity index 100%
rename from pages/en/example-solves/rouxzzcfop-7.64-ao12.mdx
rename to pages/en/zz/example-solves/rouxzzcfop-7.64-ao12.mdx
diff --git a/pages/en/example-solves/yoruba-5.86-ao5.mdx b/pages/en/zz/example-solves/yoruba-5.86-ao5.mdx
similarity index 100%
rename from pages/en/example-solves/yoruba-5.86-ao5.mdx
rename to pages/en/zz/example-solves/yoruba-5.86-ao5.mdx
diff --git a/pages/en/example-solves/yoruba-6.65-ao25.mdx b/pages/en/zz/example-solves/yoruba-6.65-ao25.mdx
similarity index 100%
rename from pages/en/example-solves/yoruba-6.65-ao25.mdx
rename to pages/en/zz/example-solves/yoruba-6.65-ao25.mdx
diff --git a/pages/en/example-solves/yoruba-7.19-ao50.mdx b/pages/en/zz/example-solves/yoruba-7.19-ao50.mdx
similarity index 100%
rename from pages/en/example-solves/yoruba-7.19-ao50.mdx
rename to pages/en/zz/example-solves/yoruba-7.19-ao50.mdx
diff --git a/pages/en/example-solves/yoruba-advanced-example-25.mdx b/pages/en/zz/example-solves/yoruba-advanced-example-25.mdx
similarity index 100%
rename from pages/en/example-solves/yoruba-advanced-example-25.mdx
rename to pages/en/zz/example-solves/yoruba-advanced-example-25.mdx
diff --git a/pages/en/improvement-guide.mdx b/pages/en/zz/improvement-guide.mdx
similarity index 68%
rename from pages/en/improvement-guide.mdx
rename to pages/en/zz/improvement-guide.mdx
index 6541481..cbe4d62 100644
--- a/pages/en/improvement-guide.mdx
+++ b/pages/en/zz/improvement-guide.mdx
@@ -7,6 +7,6 @@ author: crystalcuber
Welcome to the Modern ZZ Improvement Guide.
We have comprehensive articles for advanced techniques, practice tips and general advice so you can reach your potential!
-1. [EOCross guide](/improvement-guide/eocross)
-2. [ZZF2L guide](/improvement-guide/zzf2l)
-3. [LL guide](/improvement-guide/ll)
+1. [EOCross guide](/zz/improvement-guide/eocross)
+2. [ZZF2L guide](/zz/improvement-guide/zzf2l)
+3. [LL guide](/zz/improvement-guide/ll)
diff --git a/pages/en/improvement-guide/_meta.tsx b/pages/en/zz/improvement-guide/_meta.tsx
similarity index 100%
rename from pages/en/improvement-guide/_meta.tsx
rename to pages/en/zz/improvement-guide/_meta.tsx
diff --git a/pages/he/improvement-guide/eocross.mdx b/pages/en/zz/improvement-guide/eocross.mdx
similarity index 84%
rename from pages/he/improvement-guide/eocross.mdx
rename to pages/en/zz/improvement-guide/eocross.mdx
index c33ef67..f7da9e5 100644
--- a/pages/he/improvement-guide/eocross.mdx
+++ b/pages/en/zz/improvement-guide/eocross.mdx
@@ -7,4 +7,4 @@ author: crystalcuber
Introducing the comprehensive EOCross guide! It breaks down the most complex step of ZZ with systematic approaches.
Included is the Movecount Drill, an exercise with proven results for increasing EOCross efficiency.
-[Start here!](/improvement-guide/eocross/eocross-full-guide)
+[Start here!](/zz/improvement-guide/eocross/eocross-full-guide)
diff --git a/pages/en/improvement-guide/eocross/_meta.tsx b/pages/en/zz/improvement-guide/eocross/_meta.tsx
similarity index 100%
rename from pages/en/improvement-guide/eocross/_meta.tsx
rename to pages/en/zz/improvement-guide/eocross/_meta.tsx
diff --git a/pages/he/improvement-guide/eocross/color-neutrality.mdx b/pages/en/zz/improvement-guide/eocross/color-neutrality.mdx
similarity index 90%
rename from pages/he/improvement-guide/eocross/color-neutrality.mdx
rename to pages/en/zz/improvement-guide/eocross/color-neutrality.mdx
index d097321..fcfef61 100644
--- a/pages/he/improvement-guide/eocross/color-neutrality.mdx
+++ b/pages/en/zz/improvement-guide/eocross/color-neutrality.mdx
@@ -12,7 +12,7 @@ In this page, we will explain how CN works and how to learn the main options for
**Cube orientation** is the angle at which the cube is held, based on the position of the center pieces. For example, scramble orientation is the conventional way to hold the cube during scrambling, with the white center at the top and green center at the front. Usually, cube orientations are described by the top and front centers, and abbreviated like "white top green front".
-An **EO axis** (plural: axes) is a pair of two centers at the Front or Back that determine which edges are good or bad. For example, if a scrambled cube has the orange center at the Front and red center at the Back, that is the orange/red or red/orange axis. From the [EO tutorial](/tutorial/eo), we learned that the bad edges may change when holding the cube in different orientations. However, as long as the orange/red centers are both at the Front/Back in any order, the bad edges will actually be the same. In total, there are three EO axes on the cube (red/orange, green/blue, white/yellow).
+An **EO axis** (plural: axes) is a pair of two centers at the Front or Back that determine which edges are good or bad. For example, if a scrambled cube has the orange center at the Front and red center at the Back, that is the orange/red or red/orange axis. From the [EO tutorial](/zz/tutorial/eo), we learned that the bad edges may change when holding the cube in different orientations. However, as long as the orange/red centers are both at the Front/Back in any order, the bad edges will actually be the same. In total, there are three EO axes on the cube (red/orange, green/blue, white/yellow).
EOCross is a combination of solving the cross pieces of a certain color, and solving the EO of a certain axis.
@@ -20,7 +20,7 @@ EOCross is a combination of solving the cross pieces of a certain color, and sol
### Fixed
-**Fixed** means always starting the solve from one specific cube orientation. This gives you only one EO axis and one cross color to work with, so there is only one EOCross option to consider. One might also notice that you can do a y2 to get the same EO and cross, which is true (we will go over this in the [practicing](/improvement-guide/eocross/practicing) article).
+**Fixed** means always starting the solve from one specific cube orientation. This gives you only one EO axis and one cross color to work with, so there is only one EOCross option to consider. One might also notice that you can do a y2 to get the same EO and cross, which is true (we will go over this in the [practicing](/zz/improvement-guide/eocross/practicing) article).
The most common choice by beginners, which can also be solid at a high level.
diff --git a/pages/en/improvement-guide/eocross/efficiency.mdx b/pages/en/zz/improvement-guide/eocross/efficiency.mdx
similarity index 99%
rename from pages/en/improvement-guide/eocross/efficiency.mdx
rename to pages/en/zz/improvement-guide/eocross/efficiency.mdx
index 88fea71..8539a25 100644
--- a/pages/en/improvement-guide/eocross/efficiency.mdx
+++ b/pages/en/zz/improvement-guide/eocross/efficiency.mdx
@@ -78,7 +78,7 @@ If you're really stuck, go to Solvers > EOCross to see what the computer will gi
Eventually, after doing the drill a couple of times, your average movecount will drop. Apply a new target movecount for progression, and repeat the drill.
-Continue doing this process until your average movecount drops to 8.5. Then, stop caring about movecount and start practicing for [speed](/improvement-guide/eocross/practicing).
+Continue doing this process until your average movecount drops to 8.5. Then, stop caring about movecount and start practicing for [speed](/zz/improvement-guide/eocross/practicing).
## How to solve EOCross as one step
diff --git a/pages/en/improvement-guide/eocross/eocross-full-guide.mdx b/pages/en/zz/improvement-guide/eocross/eocross-full-guide.mdx
similarity index 84%
rename from pages/en/improvement-guide/eocross/eocross-full-guide.mdx
rename to pages/en/zz/improvement-guide/eocross/eocross-full-guide.mdx
index e072363..850162c 100644
--- a/pages/en/improvement-guide/eocross/eocross-full-guide.mdx
+++ b/pages/en/zz/improvement-guide/eocross/eocross-full-guide.mdx
@@ -14,7 +14,7 @@ Here's a step by step guide on how to get your EOCross skills from a beginner to
-### [Learn EO](/tutorial/eo)
+### [Learn EO](/zz/tutorial/eo)
Focus on efficiency and aim for 4-5 move solutions on average.
@@ -28,15 +28,15 @@ If you haven't already, learn how EO gets affected by F and B moves when 1/2/3 b
### Apply basic EOCross techniques
-The most bang for your buck will be to use different direction of F/B moves, and implement 2 edge F/B turns for flexibility. Use the movecount drill to get down to 10 moves on average. For more techniques and drills, check out the [efficiency](/improvement-guide/eocross/efficiency) and [practicing](/improvement-guide/eocross/practicing) articles.
+The most bang for your buck will be to use different direction of F/B moves, and implement 2 edge F/B turns for flexibility. Use the movecount drill to get down to 10 moves on average. For more techniques and drills, check out the [efficiency](/zz/improvement-guide/eocross/efficiency) and [practicing](/zz/improvement-guide/eocross/practicing) articles.
### Improve EOCross efficiency and planning
-Practice until you can plan EO+2 every time. Do lots of efficiency practice with previously mentioned techniques and use [crystalcube](https://crystalcube.app/) to get movecount down to 8.5. Improved efficiency will make it easier for you to plan EOCross in [inspection](/improvement-guide/eocross/inspection). Work on that.
+Practice until you can plan EO+2 every time. Do lots of efficiency practice with previously mentioned techniques and use [crystalcube](https://crystalcube.app/) to get movecount down to 8.5. Improved efficiency will make it easier for you to plan EOCross in [inspection](/zz/improvement-guide/eocross/inspection). Work on that.
### Improve EOCross speed
-After that, focus more on the speed and execution of the step. Practice with the drill, this time focusing on speed. For more information, see the speed section of the [Practicing](/improvement-guide/eocross/practicing) article. Along with that, practice planning EOCross faster in inspection.
+After that, focus more on the speed and execution of the step. Practice with the drill, this time focusing on speed. For more information, see the speed section of the [Practicing](/zz/improvement-guide/eocross/practicing) article. Along with that, practice planning EOCross faster in inspection.
A good goal to aim for is to plan EOCross within 8 seconds of inspection, being able to execute it in 1.5 seconds, in 9 or less moves on average. This is the skill level equivalent of a 6.5 seconds solver.
diff --git a/pages/en/improvement-guide/eocross/inspection.mdx b/pages/en/zz/improvement-guide/eocross/inspection.mdx
similarity index 96%
rename from pages/en/improvement-guide/eocross/inspection.mdx
rename to pages/en/zz/improvement-guide/eocross/inspection.mdx
index 9c93511..d5c0799 100644
--- a/pages/en/improvement-guide/eocross/inspection.mdx
+++ b/pages/en/zz/improvement-guide/eocross/inspection.mdx
@@ -10,14 +10,14 @@ Here you will learn how to consistently plan EOCross in inspection (15 seconds o
## Prerequisites
-Before learning to plan EOCross, your EO recognition needs to be well-practiced and only take a few seconds. The rules of recognition are no longer rules, but something you can see without conscious effort. In addition, some "training wheel" habits given in the [EO tutorial](/tutorial/eo) should no longer be used:
+Before learning to plan EOCross, your EO recognition needs to be well-practiced and only take a few seconds. The rules of recognition are no longer rules, but something you can see without conscious effort. In addition, some "training wheel" habits given in the [EO tutorial](/zz/tutorial/eo) should no longer be used:
- Placing fingers on bad edges.
- Keeping track of only good edges when there are more good than bad.
## Intermediate approach
-1. If you're [colour neutral](/improvement-guide/eocross/color-neutrality), pick an option with an easier EO. \
+1. If you're [colour neutral](/zz/improvement-guide/eocross/color-neutrality), pick an option with an easier EO. \
a. Check the available EO axes. For x2y, there are two axes. \
b. Check the available cross pieces. For x2y, there are two sets of cross pieces.
2. Find an efficient **EO+2** solution (EO plus two cross edges).
diff --git a/pages/he/improvement-guide/eocross/practicing.mdx b/pages/en/zz/improvement-guide/eocross/practicing.mdx
similarity index 96%
rename from pages/he/improvement-guide/eocross/practicing.mdx
rename to pages/en/zz/improvement-guide/eocross/practicing.mdx
index 2df12ee..862cd96 100644
--- a/pages/he/improvement-guide/eocross/practicing.mdx
+++ b/pages/en/zz/improvement-guide/eocross/practicing.mdx
@@ -34,7 +34,7 @@ While it is important, low movecount isn't everything. We want our solutions to
### Ergonomics
- Don't go for solutions that have a lot of F2/B2 moves. In your solution, one such move is fine, two such moves should be reasonably justified and never do them 3 times or more.
-- [Color neutrality](/improvement-guide/eocross/color-neutrality) helps a lot here. CN and x2y solvers will have a lot of advantage over fixed solvers for being able to choose between multiple options.
+- [Color neutrality](/zz/improvement-guide/eocross/color-neutrality) helps a lot here. CN and x2y solvers will have a lot of advantage over fixed solvers for being able to choose between multiple options.
- Executing your planned solution from a y2 away can greatly improve the ergonomics of your solution. You can do that, because after a y2, the EO axis and the cross color stays the same. This is most used during solutions with a lot of singular B moves, in these cases you can just do a y2 to turn the B moves into easier to execute F moves.
Here's an [example](https://alpha.twizzle.net/edit/?stickering=EOcross&setup-alg=U'+L2+U2+B2+U+R2+D+F2+R2+D+R2+D'+L'+U'+R+B'+U+B+R+B2+D&alg=%2F%2Fwe+can+solve+this+case+with+L'+B'+D'+B'+L+R2%2C+however%2C+the+ergonomics+are+pretty+bad.+We+can+instead+do+a+y2+before+the+solution%3A%0Ay2+R'+F'+D'+F'+R+L2+%2F%2Fand+thats+much+nicer+to+execute).
- Prioritize solutions with triggers in them.
diff --git a/pages/he/improvement-guide/eocross/xeocross.mdx b/pages/en/zz/improvement-guide/eocross/xeocross.mdx
similarity index 97%
rename from pages/he/improvement-guide/eocross/xeocross.mdx
rename to pages/en/zz/improvement-guide/eocross/xeocross.mdx
index d089a71..12907f6 100644
--- a/pages/he/improvement-guide/eocross/xeocross.mdx
+++ b/pages/en/zz/improvement-guide/eocross/xeocross.mdx
@@ -10,8 +10,7 @@ import { Callout } from "nextra/components";
**XEOCross** is an EOCross and one F2L pair, both solved at the same time. It stands for eXtended EOCross, and looks like this:
Prerequisite: Get comfortable with [keyhole
- F2L](/improvement-guide/zzf2l/pair-solutions#edge-keyhole).
+ F2L](/zz/improvement-guide/zzf2l/pair-solutions#edge-keyhole).
If you see that an F2L edge or a corner ends up solved after an EOCross, you can try to keyhole insert the remaining edge/corner. (This ties into planning more than EOCross in inspection and seeing ahead into your F2L). Here’s an example: [Example 3](https://alpha.twizzle.net/edit/?title=XEOCross+Example+3&puzzle=3x3x3&setup-alg=F2+U%27+L2+U%27+L2+D+B2+F2+R2+D+L+U2+F%27+U+B%27+D+U%27+R+D2+B&alg=y%27+%2F%2F+Let%27s+say+you+planned+U+L+R%27+U%27+F%27+D2+F2+R+D%27+for+your+EOCross.+Notice+that+after+the+first+5+moves%2C+the+yellow-red-green+2x2x1+block+has+formed.+Let%27s+see+if+we+can+also+solve+the+red-green+edge+that+turns+it+into+a+2x2x2.%0A%0AU+L+R%27+U%27+F%27+%2F%2F+Here%27s+our+block.%0A%0AD2+F2+%2F%2F+We+can+see+the+red-green+edge.+Before+the+following+R+move%2C+we+can+add+a+U%27+which+will+make+the+R+solve+the+red-green+edge+in+addition+to+the+cross+edge.+This+is+a+strategy+called+Keyhole%21%0A%0AU%27+R+D%27+%2F%2F+And+there%27s+our+XEOCross%21)
diff --git a/pages/en/improvement-guide/ll.mdx b/pages/en/zz/improvement-guide/ll.mdx
similarity index 67%
rename from pages/en/improvement-guide/ll.mdx
rename to pages/en/zz/improvement-guide/ll.mdx
index 61c3370..5e32a13 100644
--- a/pages/en/improvement-guide/ll.mdx
+++ b/pages/en/zz/improvement-guide/ll.mdx
@@ -5,6 +5,6 @@ author: crystalcuber
---
This is the complete Last Layer improvement guide written by a high-level ZBLL user.
-Inside you'll find great advice on how to learn and train algs, especially [ZBLL](/improvement-guide/ll/zbll-guide).
+Inside you'll find great advice on how to learn and train algs, especially [ZBLL](/zz/improvement-guide/ll/zbll-guide).
-To upgrade from 3LLL to 2LLL, [start here!](/improvement-guide/ll/2lll)
+To upgrade from 3LLL to 2LLL, [start here!](/zz/improvement-guide/ll/2lll)
diff --git a/pages/en/improvement-guide/ll/2lll.mdx b/pages/en/zz/improvement-guide/ll/2lll.mdx
similarity index 100%
rename from pages/en/improvement-guide/ll/2lll.mdx
rename to pages/en/zz/improvement-guide/ll/2lll.mdx
diff --git a/pages/en/improvement-guide/ll/_meta.tsx b/pages/en/zz/improvement-guide/ll/_meta.tsx
similarity index 100%
rename from pages/en/improvement-guide/ll/_meta.tsx
rename to pages/en/zz/improvement-guide/ll/_meta.tsx
diff --git a/pages/en/improvement-guide/ll/zbll-algs.mdx b/pages/en/zz/improvement-guide/ll/zbll-algs.mdx
similarity index 100%
rename from pages/en/improvement-guide/ll/zbll-algs.mdx
rename to pages/en/zz/improvement-guide/ll/zbll-algs.mdx
diff --git a/pages/he/improvement-guide/ll/zbll-guide.mdx b/pages/en/zz/improvement-guide/ll/zbll-guide.mdx
similarity index 84%
rename from pages/he/improvement-guide/ll/zbll-guide.mdx
rename to pages/en/zz/improvement-guide/ll/zbll-guide.mdx
index 727397d..66637ae 100644
--- a/pages/he/improvement-guide/ll/zbll-guide.mdx
+++ b/pages/en/zz/improvement-guide/ll/zbll-guide.mdx
@@ -41,13 +41,13 @@ The reason for this path of learning is that you're starting with the sets that
## Recog
-Of course, you also need to know how to recognize the cases from each other. There are multiple ways, but the most consistent is Baum-Harris. Learn more about recog [here](/improvement-guide/ll/zbll-recog).
+Of course, you also need to know how to recognize the cases from each other. There are multiple ways, but the most consistent is Baum-Harris. Learn more about recog [here](/zz/improvement-guide/ll/zbll-recog).
## Learning a set
-Choose your algorithms by going through the [ZBLL sheets](/improvement-guide/ll/zbll-algs). Try out different algs and check which ones work the most for you. Just a tip: do not overthink this process. You might fall into the trap of being too indecisive about choosing between 2 algs that probably have a 0.1 difference between them at best. If you ever catch yourself in this situation, pick whichever. You can always switch out the alg later. Add them to your own sheet.
+Choose your algorithms by going through the [ZBLL sheets](/zz/improvement-guide/ll/zbll-algs). Try out different algs and check which ones work the most for you. Just a tip: do not overthink this process. You might fall into the trap of being too indecisive about choosing between 2 algs that probably have a 0.1 difference between them at best. If you ever catch yourself in this situation, pick whichever. You can always switch out the alg later. Add them to your own sheet.
-To practice these algs, here's [everything covered for you.](/improvement-guide/ll/zbll-practice)
+To practice these algs, here's [everything covered for you.](/zz/improvement-guide/ll/zbll-practice)
## Maintaining a set
diff --git a/pages/en/improvement-guide/ll/zbll-practice.mdx b/pages/en/zz/improvement-guide/ll/zbll-practice.mdx
similarity index 100%
rename from pages/en/improvement-guide/ll/zbll-practice.mdx
rename to pages/en/zz/improvement-guide/ll/zbll-practice.mdx
diff --git a/pages/en/improvement-guide/ll/zbll-recog.mdx b/pages/en/zz/improvement-guide/ll/zbll-recog.mdx
similarity index 100%
rename from pages/en/improvement-guide/ll/zbll-recog.mdx
rename to pages/en/zz/improvement-guide/ll/zbll-recog.mdx
diff --git a/pages/he/improvement-guide/zzf2l.mdx b/pages/en/zz/improvement-guide/zzf2l.mdx
similarity index 86%
rename from pages/he/improvement-guide/zzf2l.mdx
rename to pages/en/zz/improvement-guide/zzf2l.mdx
index 0bbf476..1a9a3b0 100644
--- a/pages/he/improvement-guide/zzf2l.mdx
+++ b/pages/en/zz/improvement-guide/zzf2l.mdx
@@ -9,4 +9,4 @@ These tutorials, practice drills and advice can take your F2L to the next level.
This guide is for EOCross ZZF2L. For EOLine ZZF2L, refer to [Conrad Rider's guide](http://cube.rider.biz/zz.php?p=f2l).
-[Start here!](/improvement-guide/zzf2l/zzf2l-full-guide)
+[Start here!](/zz/improvement-guide/zzf2l/zzf2l-full-guide)
diff --git a/pages/en/improvement-guide/zzf2l/_meta.tsx b/pages/en/zz/improvement-guide/zzf2l/_meta.tsx
similarity index 100%
rename from pages/en/improvement-guide/zzf2l/_meta.tsx
rename to pages/en/zz/improvement-guide/zzf2l/_meta.tsx
diff --git a/pages/he/improvement-guide/zzf2l/deduction.mdx b/pages/en/zz/improvement-guide/zzf2l/deduction.mdx
similarity index 88%
rename from pages/he/improvement-guide/zzf2l/deduction.mdx
rename to pages/en/zz/improvement-guide/zzf2l/deduction.mdx
index b7047a3..a668912 100644
--- a/pages/he/improvement-guide/zzf2l/deduction.mdx
+++ b/pages/en/zz/improvement-guide/zzf2l/deduction.mdx
@@ -16,8 +16,7 @@ During F2L, one of the challenges is determining where your F2L pieces are. Some
## Easiest: all stickers visible
Explanation:
Since EOCross is solved, all bottom edges are solved. So during F2L, there are two types of edges: F2L edges (belonging to an F2L pair) and LL edges. LL edges belong to the top (U) layer, so they'll always have a U sticker.
-Typically, you need to see both stickers of an edge to tell if it's a LL edge. However, there is a special rule for stickers on the ['purple orbit'](/tutorial/eo#orbits). Because EO is solved, U stickers will always be on the purple orbit. This means: if an edge is an LL edge, you will see a U sticker on the purple orbit. If you don't see a U sticker there, the edge is an F2L edge.
+Typically, you need to see both stickers of an edge to tell if it's a LL edge. However, there is a special rule for stickers on the ['purple orbit'](/zz/tutorial/eo#orbits). Because EO is solved, U stickers will always be on the purple orbit. This means: if an edge is an LL edge, you will see a U sticker on the purple orbit. If you don't see a U sticker there, the edge is an F2L edge.
You can use this rule together with the process of elimination. Here's an example:
@@ -127,4 +122,4 @@ But the LL Edge Rule says: the UB edge doesn't have a U sticker on the purple or
### Track pieces beforehand
-One more strategy for 'hard' pieces is to [lookahead during F2L](/improvement-guide/zzf2l/lookahead) and track pieces that you are not currently solving. Some pieces you track can start visible, but after solving a F2L pair they end up on the back. If you watch where pieces are moving, you can identify a 'hard' piece before it even becomes 'hard'.
+One more strategy for 'hard' pieces is to [lookahead during F2L](/zz/improvement-guide/zzf2l/lookahead) and track pieces that you are not currently solving. Some pieces you track can start visible, but after solving a F2L pair they end up on the back. If you watch where pieces are moving, you can identify a 'hard' piece before it even becomes 'hard'.
diff --git a/pages/en/improvement-guide/zzf2l/lookahead.mdx b/pages/en/zz/improvement-guide/zzf2l/lookahead.mdx
similarity index 95%
rename from pages/en/improvement-guide/zzf2l/lookahead.mdx
rename to pages/en/zz/improvement-guide/zzf2l/lookahead.mdx
index d0aa82b..176dbde 100644
--- a/pages/en/improvement-guide/zzf2l/lookahead.mdx
+++ b/pages/en/zz/improvement-guide/zzf2l/lookahead.mdx
@@ -71,8 +71,7 @@ For example, if the first thing we see is the green-orange pair, it results in a
experimentalSetupAlg="z2"
alg="(U R U' R' U' R U' R' U R U' R') (R' U' R U' R' U' R)"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-ID,CORNERS:IID-IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-ID,CORNERS:IID-IIII,CENTERS:DDDDDD"
tempoScale="3"
/>
Moves: `(U R U' R' U' R U' R' U R U' R') (R' U' R U' R' U' R)`
@@ -83,8 +82,7 @@ However, if we solve the blue-orange pair first, we have a much nicer 5-mover an
experimentalSetupAlg="z2"
alg="(R U' R2' U' R) (R U R' U2' R U R')"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-I-,CORNERS:II--IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-I-,CORNERS:II--IIII,CENTERS:DDDDDD"
tempoScale="3"
/>
Moves: `(R U' R2' U' R) (R U R' U2' R U R')`
@@ -93,13 +91,13 @@ Tunnel vision is common even at a higher level of cubing (sub 8-10), and it's al
It's a major downside of the above drills, if not addressed.
-**Solution:** Improve [Pair Choice](/improvement-guide/zzf2l/pair-choice) + Be more aware of your other pairs
+**Solution:** Improve [Pair Choice](/zz/improvement-guide/zzf2l/pair-choice) + Be more aware of your other pairs
### Problem #2: Can't see pieces
You may be solving an F2L pair and trying to spot the pieces for your next one, but you can't spot anything. Annoying, but it's easier to address than the first problem.
-Solution: [Deduction](/improvement-guide/zzf2l/deduction) + pair choice (prioritizing back slots)
+Solution: [Deduction](/zz/improvement-guide/zzf2l/deduction) + pair choice (prioritizing back slots)
Address these 2 problems and continue training your lookahead with the drill until you can lookahead comfortably with your normal turning speed.
@@ -121,8 +119,7 @@ To accelerate the process, you can go over each case manually and learn how each
experimentalSetupAlg="z2"
alg="R U2 R' U' R U R'"
experimentalSetupAnchor="end"
- background="none"
- tempoScale="2"
+ tempoScale="2"
/>
Moves: `R U2 R' U' R U R'`
diff --git a/pages/he/improvement-guide/zzf2l/multislotting.mdx b/pages/en/zz/improvement-guide/zzf2l/multislotting.mdx
similarity index 84%
rename from pages/he/improvement-guide/zzf2l/multislotting.mdx
rename to pages/en/zz/improvement-guide/zzf2l/multislotting.mdx
index dab3943..52641ec 100644
--- a/pages/he/improvement-guide/zzf2l/multislotting.mdx
+++ b/pages/en/zz/improvement-guide/zzf2l/multislotting.mdx
@@ -19,8 +19,7 @@ Why do that? It will give you a general understanding of when to apply multislot
@@ -34,8 +33,7 @@ Why do that? It will give you a general understanding of when to apply multislot
@@ -52,8 +50,7 @@ doesn't.
Good solution (shown above): insert FL with `U`:
@@ -65,7 +62,7 @@ Influencing is mostly useful when, as stated before, you realize that after solv
## Pseudoslotting
-Remember [keyhole](/improvement-guide/zzf2l/pair-solutions#edge-keyhole)? Pseudoslotting is basically that, but you solve both an edge of one pair and the corner of another pair to solve 2 pairs at once. You can treat the edge and corner that you're solving much like a F2L pair, but because they don't match, the recognition relies entirely on the position of the two pieces and the orientation of the corner.
+Remember [keyhole](/zz/improvement-guide/zzf2l/pair-solutions#edge-keyhole)? Pseudoslotting is basically that, but you solve both an edge of one pair and the corner of another pair to solve 2 pairs at once. You can treat the edge and corner that you're solving much like a F2L pair, but because they don't match, the recognition relies entirely on the position of the two pieces and the orientation of the corner.
Here's an example: DFR and FL are solved. If open slots are available, you could use keyhole to solve the DFL and FR pieces one-by-one, like this:
@@ -73,8 +70,7 @@ Here's an example: DFR and FL are solved. If open slots are available, you could
experimentalSetupAlg="z2"
alg="D R U2 R' D' D2 R' U' R D2"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:-DIDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:-DIDIIII,CENTERS:DDDDDD"
tempoScale="1.5"
/>
@@ -87,8 +83,7 @@ With pseudoslotting, you can do that all at once. Here, we can do a D move to al
experimentalSetupAlg="z2"
alg="D R U R' U2 R U' R' D'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
tempoScale="1.5"
/>
Moves: `D (R U R' U2 R U' R') D'`
@@ -106,8 +101,7 @@ In this example, the regular F2L pairs are both 7-movers, not great. But an edge
experimentalSetupAlg="z2"
alg="R U' R' D R U' R' D'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
tempoScale="1.5"
/>
Moves: `(R U' R') (D R U' R' D')`
diff --git a/pages/en/improvement-guide/zzf2l/pair-choice.mdx b/pages/en/zz/improvement-guide/zzf2l/pair-choice.mdx
similarity index 89%
rename from pages/en/improvement-guide/zzf2l/pair-choice.mdx
rename to pages/en/zz/improvement-guide/zzf2l/pair-choice.mdx
index f560a27..579ef2a 100644
--- a/pages/en/improvement-guide/zzf2l/pair-choice.mdx
+++ b/pages/en/zz/improvement-guide/zzf2l/pair-choice.mdx
@@ -14,8 +14,7 @@ In this example, there is a 3-move pair and a 4-move pair. If we chose the 3-mov
experimentalSetupAlg="z2"
alg="R U' R' U' R' U' R U' R' U R"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
/>
Moves: `(R U' R') U' (R' U' R U' R' U R)`
@@ -25,8 +24,7 @@ But if we choose the 4-mover first, the 3-mover is preserved. This is 4 moves sh
experimentalSetupAlg="z2"
alg="U' R' U' R U R U' R'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
/>
Moves: `(U' R' U' R) U (R U' R)'`
@@ -38,7 +36,7 @@ In order to consider pair choice, there are some prerequisites:
- Optimize pair solutions beforehand. If you don't do that, chances are that most of the time all of your choices would be equally as bad.
- Look at a pair, and immediately know the solution, as well as the quality of that solution. You can categorize them into 3 cases: free pairs/3 movers, 6-7 movers (pieces in U), and the rest.
-- Deduction (learn more [here](/improvement-guide/zzf2l/deduction))
+- Deduction (learn more [here](/zz/improvement-guide/zzf2l/deduction))
Developed through focused untimed f2l only solves, practice by trying out different things, looking for patterns and make sure you're aware of all of your F2L pairs.
diff --git a/pages/he/improvement-guide/zzf2l/pair-solutions.mdx b/pages/en/zz/improvement-guide/zzf2l/pair-solutions.mdx
similarity index 90%
rename from pages/he/improvement-guide/zzf2l/pair-solutions.mdx
rename to pages/en/zz/improvement-guide/zzf2l/pair-solutions.mdx
index be06cd8..8f2846d 100644
--- a/pages/he/improvement-guide/zzf2l/pair-solutions.mdx
+++ b/pages/en/zz/improvement-guide/zzf2l/pair-solutions.mdx
@@ -16,7 +16,7 @@ Here you will learn how to implement such solutions and incorporate them into yo
{/* TODO: work in progress! */}
-{/* [link](/tutorial/zzf2l) */}
+{/* [link](/zz/tutorial/zzf2l) */}
{/* (section here, to be written, tldr: be smarter about the ways to take out the pieces of the slot and how you insert them, should take 2 triggers max yada yada.First i need to know how the Intuitive F2L article will look like though) */}
{/* ## Optimizing solutions more */}
@@ -58,8 +58,7 @@ When optimizing efficiency more, take note of the alternative solutions that pri
experimentalSetupAlg="z2"
alg="R U2' R2' U' R2 U' R'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDDD-,CORNERS:DD-DIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDDD-,CORNERS:DD-DIIII,CENTERS:DDDDDD"
/>
But with the FR slot open, there's no need for that. This mean the case could now be solved with just `R U2 R2 U' R`:
@@ -68,8 +67,7 @@ But with the FR slot open, there's no need for that. This mean the case could no
experimentalSetupAlg="z2"
alg="R U2' R2' U' R"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDID-,CORNERS:DD-IIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDID-,CORNERS:DD-IIIII,CENTERS:DDDDDD"
/>
One example of these free slot solutions is **keyhole:** when you have a slot with only one solved piece, you can leverage an open slot to insert the other piece.
@@ -88,8 +86,7 @@ In Step 3, insert the edge into the slot that it belongs to. Here's an example:
experimentalSetupAlg="z2"
alg="D' R U' R' D"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:DDIDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:DDIDIIII,CENTERS:DDDDDD"
/>
Moves: `D' R U' R' D`
@@ -105,8 +102,7 @@ When inserting a corner, the D move in Step 2 should be to move the spot the cor
experimentalSetupAlg="z2"
alg="D' L' U L D"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIIIDDD,CORNERS:IDD-IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIIIDDD,CORNERS:IDD-IIII,CENTERS:DDDDDD"
/>
Moves: `D' L' U L D`
@@ -120,8 +116,7 @@ After going through LS, you could then check the cases where one of the pieces i
experimentalSetupAlg="z2"
alg="R' F2 R F2"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIII-IDD,CORNERS:-DDIIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIII-IDD,CORNERS:-DDIIIII,CENTERS:DDDDDD"
/>
-So the only cases left are the ones with both pieces in the F2L slots, what about those? Bar a few good cases, it's not recommended to learn them. Why? Because when these cases appear in a solve, there's a very high chance that there will be another F2L pair on the cube that's more efficient and faster to solve, so we could just choose that pair instead. This is called [Pair Choice](/improvement-guide/zzf2l/pair-choice).
+So the only cases left are the ones with both pieces in the F2L slots, what about those? Bar a few good cases, it's not recommended to learn them. Why? Because when these cases appear in a solve, there's a very high chance that there will be another F2L pair on the cube that's more efficient and faster to solve, so we could just choose that pair instead. This is called [Pair Choice](/zz/improvement-guide/zzf2l/pair-choice).
diff --git a/pages/he/improvement-guide/zzf2l/zzf2l-full-guide.mdx b/pages/en/zz/improvement-guide/zzf2l/zzf2l-full-guide.mdx
similarity index 82%
rename from pages/he/improvement-guide/zzf2l/zzf2l-full-guide.mdx
rename to pages/en/zz/improvement-guide/zzf2l/zzf2l-full-guide.mdx
index 3e13eca..2c522fc 100644
--- a/pages/he/improvement-guide/zzf2l/zzf2l-full-guide.mdx
+++ b/pages/en/zz/improvement-guide/zzf2l/zzf2l-full-guide.mdx
@@ -10,11 +10,11 @@ The road to improving your ZZF2L can be daunting. There are many topics to learn
-### Learn [intuitive F2L](/tutorial/zzf2l)
+### Learn [intuitive F2L](/zz/tutorial/zzf2l)
Continue until you can do it comfortably.
-### Improve your [pair solutions](/improvement-guide/zzf2l/pair-solutions)
+### Improve your [pair solutions](/zz/improvement-guide/zzf2l/pair-solutions)
Learn good solutions for Last Slot, and F2L cases with at least 1 piece in U. Also learn keyhole and solutions with free slots.
@@ -26,19 +26,19 @@ Drill them into your muscle memory with good turning. That is, you can spot the
Learn these skills together:
-- ['Tracking' lookahead](/improvement-guide/zzf2l/lookahead#how-to-start-tracking).
-- Improve [pair choice](/improvement-guide/zzf2l/pair-choice) to prevent 'tunnel vision'.
-- [Deduction](/improvement-guide/zzf2l/deduction).
+- ['Tracking' lookahead](/zz/improvement-guide/zzf2l/lookahead#how-to-start-tracking).
+- Improve [pair choice](/zz/improvement-guide/zzf2l/pair-choice) to prevent 'tunnel vision'.
+- [Deduction](/zz/improvement-guide/zzf2l/deduction).
Do untimed solves for practicing pair choice and deduction. Then, practice the lookahead drill at a slower speed for warm up, and then train your lookahead at a more challenging speed.
-### Learn ['Knowing' lookahead](/improvement-guide/zzf2l/lookahead#from-tracking-to-knowing)
+### Learn ['Knowing' lookahead](/zz/improvement-guide/zzf2l/lookahead#from-tracking-to-knowing)
Continue doing the lookahead drill from 'Tracking' and apply the techniques there to accelerate the process.
Once you achieve that, focus on turning as fast as possible in F2L. Aim for 10 TPS (turns per second). Do solves where you only time your F2L and aim for 2.8 seconds or lower. F2L at that time is equivalent to the level of a low-mid 6s ZZer. If you have achieved 'Knowing' lookahead and applied all the previous techniques, that would only require good turning (which I assume you have already developed). Proceed if you have achieved that benchmark.
-### Learn [multislotting](/improvement-guide/zzf2l/multislotting)
+### Learn [multislotting](/zz/improvement-guide/zzf2l/multislotting)
This is the final step for optimizing efficiency. Implement influencing, pseudoslotting and learn algorithms for bad Last Two Pairs cases. After this, your ZZF2L should be under 26 moves on average.
diff --git a/pages/he/index.mdx b/pages/en/zz/index.mdx
similarity index 87%
rename from pages/he/index.mdx
rename to pages/en/zz/index.mdx
index ec39b5f..240548a 100644
--- a/pages/he/index.mdx
+++ b/pages/en/zz/index.mdx
@@ -12,11 +12,11 @@ ZZ is a speedsolving method for the 3x3 Rubik's Cube. Its most distinctive featu
There are three steps:
-1. [**EOCross**](/tutorial/eocross): solve EO and a cross at the same time. An alternative is EOLine.
-2. [**ZZF2L**](/tutorial/zzf2l): complete the First 2 Layers with R, U, L and D turns. No cube rotations required.
-3. [**Last Layer**](/tutorial/ll): solve the top layer with a reduced number of cases.
+1. [**EOCross**](/zz/tutorial/eocross): solve EO and a cross at the same time. An alternative is EOLine.
+2. [**ZZF2L**](/zz/tutorial/zzf2l): complete the First 2 Layers with R, U, L and D turns. No cube rotations required.
+3. [**Last Layer**](/zz/tutorial/ll): solve the top layer with a reduced number of cases.
-Yoruba achieved an average movecount of [55.42 STM](/example-solves/yoruba-7.19-ao50) using ZZ.
+Yoruba achieved an average movecount of [55.42 STM](/zz/example-solves/yoruba-7.19-ao50) using ZZ.
He estimates the average movecount of ZZ to be 53.5 moves.
### Step 1: EOCross
diff --git a/pages/en/tutorial.mdx b/pages/en/zz/tutorial.mdx
similarity index 69%
rename from pages/en/tutorial.mdx
rename to pages/en/zz/tutorial.mdx
index 147b8b1..273f5c3 100644
--- a/pages/en/tutorial.mdx
+++ b/pages/en/zz/tutorial.mdx
@@ -7,14 +7,14 @@ author: crystalcuber
Welcome to the Modern ZZ Tutorial for solving the Rubik's Cube.
It features visual, beginner-friendly guides for each step of the method.
-The [EO tutorial](/tutorial/eo) introduces the principle of Edge Orientation, a core concept in ZZ.
+The [EO tutorial](/zz/tutorial/eo) introduces the principle of Edge Orientation, a core concept in ZZ.
It's also very useful for Fewest Moves Challenge (FMC), the CFOP method and Rubik's Cube theory.
Then check out the tutorials for each step:
-1. [EOCross](/tutorial/eocross)
-2. [ZZ First 2 Layers (ZZF2L)](/tutorial/zzf2l)
-3. [Last Layer (LL)](/tutorial/ll)
+1. [EOCross](/zz/tutorial/eocross)
+2. [ZZ First 2 Layers (ZZF2L)](/zz/tutorial/zzf2l)
+3. [Last Layer (LL)](/zz/tutorial/ll)
## Prerequisites
diff --git a/pages/en/tutorial/_meta.tsx b/pages/en/zz/tutorial/_meta.tsx
similarity index 100%
rename from pages/en/tutorial/_meta.tsx
rename to pages/en/zz/tutorial/_meta.tsx
diff --git a/pages/he/tutorial/eo.mdx b/pages/en/zz/tutorial/eo.mdx
similarity index 91%
rename from pages/he/tutorial/eo.mdx
rename to pages/en/zz/tutorial/eo.mdx
index fb8535e..84c6516 100644
--- a/pages/he/tutorial/eo.mdx
+++ b/pages/en/zz/tutorial/eo.mdx
@@ -46,8 +46,7 @@ Almost! This is the closest we can get, usually something like this:
@@ -89,8 +88,7 @@ Here we have a green-red edge. Let's press ▶️ and watch the green sticker, s
-The spots marked in purple, let's call it the **purple orbit**.
+The spots marked in purple, let's call that the **inner orbit**.
It covers all the edge stickers on the **U**p and **D**own sides, plus two on the **F**ront and two on the **B**ack.
Remember this, it's important later!
@@ -119,26 +116,24 @@ Press ▶️ to see!
-Also notice that every edge has one sticker in the purple orbit, and the other sticker in the outer orbit.
-For example, this bad edge has a red sticker in the purple orbit, and a green sticker in the outer orbit.
+Also notice that every edge has one sticker in the inner orbit, and the other sticker in the outer orbit.
+For example, this bad edge has a red sticker in the inner orbit, and a green sticker in the outer orbit.
In order to twist this edge, we must switch red and green around.
-But that means red (on the purple orbit) must move to where green was (on the outer orbit), which is impossible with natural moves!
+But that means red (on the inner orbit) must move to where green was (on the outer orbit), which is impossible with natural moves!
_That's why natural moves can't twist edges._
This explains why the edge is "bad".
@@ -146,8 +141,7 @@ It's only solvable if we use unnatural moves, which are the only moves that can
@@ -192,8 +186,7 @@ After that, we can choose how to hold the cube. For example, orange center top,
@@ -202,16 +195,15 @@ We have two rules for finding bad edges:
### Rule #1
-**Rule #1:** look for **L and R stickers on the purple orbit**. Their edges are bad.
+**Rule #1:** look for **L and R stickers on the inner orbit**. Their edges are bad.
"L and R stickers" means the stickers that match the color of **L**eft and **R**ight centers.
-In our example, we're looking for yellow and white stickers on the purple orbit.
+In our example, we're looking for yellow and white stickers on the inner orbit.
Edges with those stickers are bad.
@@ -227,8 +219,7 @@ We found three bad edges so far, let's mark them with tape.
@@ -259,8 +249,7 @@ We've found all 6 bad edges! Here they are.
@@ -329,8 +317,7 @@ With `F2`, it's much simpler:
@@ -427,7 +414,7 @@ You'll be able to recognize bad edges quicker, find solutions more easily and pl
## What's next?
**Congrats!** You've learned EO. We suggest doing some untimed EO solves to get more familiar with EO.
-Then you're ready to move onto [EOCross](/tutorial/eocross).
+Then you're ready to move onto [EOCross](/zz/tutorial/eocross).
## Bonus EO Example
diff --git a/pages/en/tutorial/eocross.mdx b/pages/en/zz/tutorial/eocross.mdx
similarity index 85%
rename from pages/en/tutorial/eocross.mdx
rename to pages/en/zz/tutorial/eocross.mdx
index da30e49..b17accd 100644
--- a/pages/en/tutorial/eocross.mdx
+++ b/pages/en/zz/tutorial/eocross.mdx
@@ -13,22 +13,20 @@ import { Callout } from "nextra/components";
EOCross is the first step of the modern ZZ method.
We solve two properties:
-- [Edge Orientation](/tutorial/eo).
+- [Edge Orientation](/zz/tutorial/eo).
- The **cross:** the 4 edges that belong at the bottom.
A solved EOCross looks like this:
The turquoise stickers are there to show the orientation of the unsolved edges.
-Good edges have turquoise on the ["purple orbit"](/tutorial/eo#orbits).
+Good edges have turquoise on the ["purple orbit"](/zz/tutorial/eo#orbits).
We can see that they're all good.
@@ -38,7 +36,7 @@ We can see that they're all good.
EOCross slows down the beginning of the solve compared to just solving CFOP cross.
However, EOCross sets up a rotationless, ergonomic F2L step. With EO solved, there
-is a simpler way to [deduce](/improvement-guide/zzf2l/deduction) F2L edges. Last
+is a simpler way to [deduce](/zz/improvement-guide/zzf2l/deduction) F2L edges. Last
Layer also becomes simpler. OLL and PLL is easier to learn for ZZ (28 algs instead
of 78), or you can learn full ZBLL and use it every solve.
@@ -51,11 +49,11 @@ We don't recommend EOLine as a stepping stone to EOCross for two reasons:
-In this tutorial, we'll solve EO first and then cross separately. For speed, you can later learn how to solve this as one step in the [Improvement Guide](/improvement-guide/eocross).
+In this tutorial, we'll solve EO first and then cross separately. For speed, you can later learn how to solve this as one step in the [Improvement Guide](/zz/improvement-guide/eocross).
## Step 1: EO
-The first step is to solve edge orientation. This process is explained in our [EO tutorial](/tutorial/eo).
+The first step is to solve edge orientation. This process is explained in our [EO tutorial](/zz/tutorial/eo).
## Step 2: Cross
@@ -83,11 +81,10 @@ Then we can do `R'`.
Now we know how to move any cross edge to the bottom.
@@ -95,11 +92,10 @@ We could put all cross edges on the bottom, and it would look like this.
However, this is not a solved cross!
@@ -107,10 +103,8 @@ Our goal is to solve the cross pieces, which looks something like this:
@@ -130,12 +124,11 @@ Here's an example where we use these relationships to solve cross:
There are already two cross edges at the bottom, but they don't have the right relationship.
@@ -146,11 +139,10 @@ We can fix that by replacing the green-white cross edge with the blue-white cros
Move: `R`
@@ -163,11 +155,10 @@ We can do `D2 R'` to place the blue cross edge opposite to the green cross edge,
@@ -176,11 +167,10 @@ We can finish with `D L'`.
@@ -223,9 +213,9 @@ Here are some examples of basic influencing:
- [Example 1: some influencing](https://alpha.twizzle.net/edit/?setup-alg=F%27+R2+F2+L%27+F2+L%27+U2+R+F2+U2+R+U+B+L2+D2+F+R%27+B%27+F2&alg=%2F%2F+EO+%28with+some+influencing%29%0AD%27+B+U+R%27+%2F%2F+D%E2%80%99+B+puts+3+edges+on+B+face+then+orients+them%2C+U+R%E2%80%99+puts+the+last+4+bad+edges+on+F+face%0AF+%2F%2F+we+do+F+instead+of+F%E2%80%99+because+it+places+blue+and+green+edges+relative+to+each+other+and+places+green+and+orange+edges+relative+to+each+other%0A%2F%2F+Cross%0AR%27+L2+D+L2&stickering=EOcross)
- [Example 2: more influencing](https://alpha.twizzle.net/edit/?setup-alg=F2+L2+D+B2+U+F2+U+R2+U%27+R2+F%27+U+L2+F+R%27+B+D+F+R+D2&stickering=EOcross&alg=%2F%2F+EO+%28with+more+influencing%29%0AB+%2F%2F+since+3+bad+edges+are+already+on+the+B+face%2C+we+start+EO+by+orienting+3+edges+on+the+B+face.+we+do+B+instead+of+B%E2%80%99+because+it+places+blue+and+red+edges+relative+to+each+other+nicely%0AL%27+U+R%27+U%27+%2F%2F+places+the+last+4+bad+edges+on+F%0AF%27+%2F%2F+we+do+F%E2%80%99+instead+of+F+because+it+places+orange+relative+to+the+red+and+blue+edges+we+placed+correctly+earlier%0A%2F%2F+Cross%0AR%27+D%27+L%27+D%27)
-There are many forms of influencing, [click here](/improvement-guide/eocross/efficiency#influencing) for more details.
+There are many forms of influencing, [click here](/zz/improvement-guide/eocross/efficiency#influencing) for more details.
## What's next?
We suggest doing some untimed EOCross solves to become more familiar.
-The next step is [ZZ First 2 Layers](/tutorial/zzf2l).
+The next step is [ZZ First 2 Layers](/zz/tutorial/zzf2l).
diff --git a/pages/en/tutorial/ll.mdx b/pages/en/zz/tutorial/ll.mdx
similarity index 92%
rename from pages/en/tutorial/ll.mdx
rename to pages/en/zz/tutorial/ll.mdx
index 76b93fb..738beb7 100644
--- a/pages/en/tutorial/ll.mdx
+++ b/pages/en/zz/tutorial/ll.mdx
@@ -47,10 +47,9 @@ An important pattern for OCLL recognition is called **headlights:** a pair of ma
@@ -80,10 +79,9 @@ Like in OCLL, we look for headlights, but they look a bit different:
@@ -120,10 +118,10 @@ We can combine CP and EPLL into one step called **PLL** (**P**ermutation of the
There are 21 PLL algs, but the nice part is that you'll already know 6 PLLs from CP and EPLL.
Now you will have a 2-look last layer (**2LLL**) every solve.
-Check out 2LLL [here](/improvement-guide/ll/2lll).
+Check out 2LLL [here](/zz/improvement-guide/ll/2lll).
## What about 1LLL?
You can even solve the entire Last Layer in a single step, which is a significant speed advantage.
In ZZ, you need to learn 493 algorithms in total (compared to 3916 for CFOP).
-Learn more [here](/improvement-guide/ll/zbll-guide).
+Learn more [here](/zz/improvement-guide/ll/zbll-guide).
diff --git a/pages/en/tutorial/ll.module.css b/pages/en/zz/tutorial/ll.module.css
similarity index 100%
rename from pages/en/tutorial/ll.module.css
rename to pages/en/zz/tutorial/ll.module.css
diff --git a/pages/he/tutorial/zzf2l.mdx b/pages/en/zz/tutorial/zzf2l.mdx
similarity index 79%
rename from pages/he/tutorial/zzf2l.mdx
rename to pages/en/zz/tutorial/zzf2l.mdx
index 6514f89..1590ca6 100644
--- a/pages/he/tutorial/zzf2l.mdx
+++ b/pages/en/zz/tutorial/zzf2l.mdx
@@ -10,7 +10,7 @@ import { Callout } from "nextra/components";
## Introduction
**ZZF2L** is the 2nd step of the ZZ Method.
-After [EOCross](/tutorial/eocross), complete the **First 2 Layers (F2L)** of the cube, which are the bottom two layers.
+After [EOCross](/zz/tutorial/eocross), complete the **First 2 Layers (F2L)** of the cube, which are the bottom two layers.
If you use the CFOP method, you already know how to solve F2L.
@@ -20,7 +20,7 @@ ZZF2L is the same process, except cube rotations and `F`/`B` moves are not
needed because edges are oriented.
The cases in CFOP that use rotations or `F`/`B` either never occur ZZ, or are solved with [ZZ-specific
-solutions](/improvement-guide/zzf2l/pair-solutions#main-resource-zzf2l-doc)
+solutions](/zz/improvement-guide/zzf2l/pair-solutions#main-resource-zzf2l-doc)
that keep the edges oriented.
@@ -32,23 +32,19 @@ The rest of the article does not require any knowledge of CFOP.
To complete the F2L, we need to solve four corners and four edges around the EOCross.
Each pair of matching corners and edges is called an **F2L pair**. For example, this is the front-right (FR) pair, scrambled up:
And that "gap" where a pair belongs to is called an **F2L slot**. So the FR pair belongs to the FR slot, shown above as an empty spot.
@@ -69,11 +65,9 @@ We call these two simplest ways **basic inserts**.
This is the **joined pair:** the two pieces of this F2L pair are joined together with the colors aligned.
Moves: `R U' R'`
@@ -92,11 +86,9 @@ This is the **split pair:** it looks like a joined pair that was split apart by
We can also solve this in three moves with this strategy:
Moves: `R U R'`
@@ -117,11 +109,9 @@ Here's the same F2L case on both the FR and FL pairs.
Front-right pair:
Moves: `R U2 R'`
@@ -129,11 +119,9 @@ Front-right pair:
Front-left pair:
@@ -166,10 +154,9 @@ To move a trapped piece to the top, we'll learn a general strategy.
As an example, the white-blue-orange corner is trapped in the FR slot.
Moves: `R U R'`
@@ -181,10 +168,9 @@ As an example, the white-blue-orange corner is trapped in the FR slot.
This strategy still works if both F2L pieces are trapped in the same slot:
Moves: `R U R'`
@@ -193,10 +179,9 @@ However, if exactly one piece is already at the top, there's a chance that it wi
For example, doing `R U R'` here will just trap the corner.
Moves: `R U R'`. Oh no, corner's trapped now!
@@ -208,10 +193,9 @@ Here, the first move is `R`, so then we move the pieces out of the R layer.
`U2` works. You could also do `U'`.
Moves: `R'`**`U2`**`R'`
@@ -225,10 +209,9 @@ This BR pair has both pieces trapped.
Let's lift the edge to the top.
@@ -241,10 +224,9 @@ Let's lift the edge to the top.
Then we can lift the corner to the top, but be careful because we now have the edge at the top.
@@ -263,21 +245,19 @@ The pair is now at the top, but if they're "touching" then we want to separate t
The pair is **touching** if they're right next to each other like this:
This pair is separated, which is what we want:
To separate a touching pair, there are four easy moves:
@@ -295,10 +275,9 @@ For example, in this situation we can do:
4. `R'` to move the FR slot back down.
Moves: `U R U2 R'`
@@ -309,10 +288,9 @@ For example, in this situation we can do:
Here's the FL pair, the pieces are touching and the BL slot is also unsolved.
@@ -325,12 +303,12 @@ Here's the FL pair, the pieces are touching and the BL slot is also unsolved.
-Note: if your pair is touching and is also a [joined pair](/tutorial/zzf2l#joined-pair), then you already have a basic insert ready!
-Skip to [Step 4](/tutorial/zzf2l#step-4).
+Note: if your pair is touching and is also a [joined pair](/zz/tutorial/zzf2l#joined-pair), then you already have a basic insert ready!
+Skip to [Step 4](/zz/tutorial/zzf2l#step-4).
## Step 3
-Now we'll set up the pair for a [basic insert](/tutorial/zzf2l#basic-inserts).
+Now we'll set up the pair for a [basic insert](/zz/tutorial/zzf2l#basic-inserts).
We can move the pieces around to form a joined pair or a split pair.
There are three types of cases, based on the way the corner is twisted:
@@ -344,10 +322,9 @@ We'll setup a joined pair.
Here's the strategy alongside an example:
Moves: `U2 R U R'`
@@ -365,10 +342,9 @@ Then we'll have a joined pair.
Here's the FL pair, the corner has the white D sticker on the top side so it's Case A.
@@ -393,10 +369,9 @@ The **hiding spot** for the corner is the position that is an `R2` or `L2` move
Here's the strategy for Case B:
Moves: `U' R U2 R'`
@@ -414,10 +389,9 @@ Now we'll have a joined pair!
This is the BL pair. Both pieces have green on the top, so this is Case B.
@@ -445,20 +419,18 @@ The split pair is also like this, so we'll set up to the split pair.
There are only two cases. It's either a split pair which is our goal (you can see that it's 1 move away from being joined).
Or, it's not a split pair. We'll follow a strategy very similar to Case B.
Moves: `U' R U R'`
@@ -482,10 +454,9 @@ Imagine we did an `R2`. That position would move to the top-front-right.
That's the hiding spot.
Moves: `U2 R' U' R`
@@ -512,25 +483,22 @@ The FR slot is in the R layer, so we can do a `U2` to move the pair out of the R
`U'` also works.
-Now it's time to do the basic insert. Here's the explanation from the [basic inserts section](/tutorial/zzf2l#basic-inserts) again:
+Now it's time to do the basic insert. Here's the explanation from the [basic inserts section](/zz/tutorial/zzf2l#basic-inserts) again:
1. Lift the slot to the top. (`R`)
2. Move the pair into the slot. (`U'`)
3. Bring the solved slot back down. (`R'`)
Moves: `R U' R'`
@@ -538,11 +506,9 @@ Now it's time to do the basic insert. Here's the explanation from the [basic ins
Alternatively, if we chose `U'` instead of `U2` to position the pair, our basic insert will be like this:
Moves: `R U2 R'`
@@ -557,21 +523,18 @@ The corner needs to be above the slot we're solving, and that's the only positio
In this case, do a `U'` to move the corner above the FR slot, which the pair belongs to.
-Now it's time to do the basic insert. Here's the explanation from the [basic inserts section](/tutorial/zzf2l#basic-inserts) again:
+Now it's time to do the basic insert. Here's the explanation from the [basic inserts section](/zz/tutorial/zzf2l#basic-inserts) again:
Moves: `R U R'`
@@ -590,4 +553,4 @@ There are also a lot of patterns, for example you'll be lifting slots up and put
Solutions are generally alternating between R and U moves, or L and U moves.
You'll get the hang of it!
-The next and final step is [Last Layer](/tutorial/ll).
+The next and final step is [Last Layer](/zz/tutorial/ll).
diff --git a/pages/fr/blog/story.mdx b/pages/fr/blog/story.mdx
index 5b9431b..130c43d 100644
--- a/pages/fr/blog/story.mdx
+++ b/pages/fr/blog/story.mdx
@@ -45,8 +45,7 @@ We needed to create interactive 3D cubes that would show how EO worked.
Thankfully, [`cubing.js`](https://js.cubing.net/cubing/) is an amazing tool that helped us build these visualizations.
diff --git a/pages/fr/improvement-guide/zzf2l/lookahead.mdx b/pages/fr/improvement-guide/zzf2l/lookahead.mdx
index d0aa82b..620fd13 100644
--- a/pages/fr/improvement-guide/zzf2l/lookahead.mdx
+++ b/pages/fr/improvement-guide/zzf2l/lookahead.mdx
@@ -71,8 +71,7 @@ For example, if the first thing we see is the green-orange pair, it results in a
experimentalSetupAlg="z2"
alg="(U R U' R' U' R U' R' U R U' R') (R' U' R U' R' U' R)"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-ID,CORNERS:IID-IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-ID,CORNERS:IID-IIII,CENTERS:DDDDDD"
tempoScale="3"
/>
Moves: `(U R U' R' U' R U' R' U R U' R') (R' U' R U' R' U' R)`
@@ -83,8 +82,7 @@ However, if we solve the blue-orange pair first, we have a much nicer 5-mover an
experimentalSetupAlg="z2"
alg="(R U' R2' U' R) (R U R' U2' R U R')"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-I-,CORNERS:II--IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-I-,CORNERS:II--IIII,CENTERS:DDDDDD"
tempoScale="3"
/>
Moves: `(R U' R2' U' R) (R U R' U2' R U R')`
@@ -121,8 +119,7 @@ To accelerate the process, you can go over each case manually and learn how each
experimentalSetupAlg="z2"
alg="R U2 R' U' R U R'"
experimentalSetupAnchor="end"
- background="none"
- tempoScale="2"
+ tempoScale="2"
/>
Moves: `R U2 R' U' R U R'`
diff --git a/pages/fr/improvement-guide/zzf2l/multislotting.mdx b/pages/fr/improvement-guide/zzf2l/multislotting.mdx
index dab3943..ad2bec1 100644
--- a/pages/fr/improvement-guide/zzf2l/multislotting.mdx
+++ b/pages/fr/improvement-guide/zzf2l/multislotting.mdx
@@ -19,8 +19,7 @@ Why do that? It will give you a general understanding of when to apply multislot
@@ -34,8 +33,7 @@ Why do that? It will give you a general understanding of when to apply multislot
@@ -52,8 +50,7 @@ doesn't.
Good solution (shown above): insert FL with `U`:
@@ -73,8 +70,7 @@ Here's an example: DFR and FL are solved. If open slots are available, you could
experimentalSetupAlg="z2"
alg="D R U2 R' D' D2 R' U' R D2"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:-DIDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:-DIDIIII,CENTERS:DDDDDD"
tempoScale="1.5"
/>
@@ -87,8 +83,7 @@ With pseudoslotting, you can do that all at once. Here, we can do a D move to al
experimentalSetupAlg="z2"
alg="D R U R' U2 R U' R' D'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
tempoScale="1.5"
/>
Moves: `D (R U R' U2 R U' R') D'`
@@ -106,8 +101,7 @@ In this example, the regular F2L pairs are both 7-movers, not great. But an edge
experimentalSetupAlg="z2"
alg="R U' R' D R U' R' D'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
tempoScale="1.5"
/>
Moves: `(R U' R') (D R U' R' D')`
diff --git a/pages/fr/improvement-guide/zzf2l/pair-choice.mdx b/pages/fr/improvement-guide/zzf2l/pair-choice.mdx
index f560a27..0d07373 100644
--- a/pages/fr/improvement-guide/zzf2l/pair-choice.mdx
+++ b/pages/fr/improvement-guide/zzf2l/pair-choice.mdx
@@ -14,8 +14,7 @@ In this example, there is a 3-move pair and a 4-move pair. If we chose the 3-mov
experimentalSetupAlg="z2"
alg="R U' R' U' R' U' R U' R' U R"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
/>
Moves: `(R U' R') U' (R' U' R U' R' U R)`
@@ -25,8 +24,7 @@ But if we choose the 4-mover first, the 3-mover is preserved. This is 4 moves sh
experimentalSetupAlg="z2"
alg="U' R' U' R U R U' R'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
/>
Moves: `(U' R' U' R) U (R U' R)'`
diff --git a/pages/fr/improvement-guide/zzf2l/pair-solutions.mdx b/pages/fr/improvement-guide/zzf2l/pair-solutions.mdx
index be06cd8..904faba 100644
--- a/pages/fr/improvement-guide/zzf2l/pair-solutions.mdx
+++ b/pages/fr/improvement-guide/zzf2l/pair-solutions.mdx
@@ -58,8 +58,7 @@ When optimizing efficiency more, take note of the alternative solutions that pri
experimentalSetupAlg="z2"
alg="R U2' R2' U' R2 U' R'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDDD-,CORNERS:DD-DIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDDD-,CORNERS:DD-DIIII,CENTERS:DDDDDD"
/>
But with the FR slot open, there's no need for that. This mean the case could now be solved with just `R U2 R2 U' R`:
@@ -68,8 +67,7 @@ But with the FR slot open, there's no need for that. This mean the case could no
experimentalSetupAlg="z2"
alg="R U2' R2' U' R"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDID-,CORNERS:DD-IIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDID-,CORNERS:DD-IIIII,CENTERS:DDDDDD"
/>
One example of these free slot solutions is **keyhole:** when you have a slot with only one solved piece, you can leverage an open slot to insert the other piece.
@@ -88,8 +86,7 @@ In Step 3, insert the edge into the slot that it belongs to. Here's an example:
experimentalSetupAlg="z2"
alg="D' R U' R' D"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:DDIDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:DDIDIIII,CENTERS:DDDDDD"
/>
Moves: `D' R U' R' D`
@@ -105,8 +102,7 @@ When inserting a corner, the D move in Step 2 should be to move the spot the cor
experimentalSetupAlg="z2"
alg="D' L' U L D"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIIIDDD,CORNERS:IDD-IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIIIDDD,CORNERS:IDD-IIII,CENTERS:DDDDDD"
/>
Moves: `D' L' U L D`
@@ -120,8 +116,7 @@ After going through LS, you could then check the cases where one of the pieces i
experimentalSetupAlg="z2"
alg="R' F2 R F2"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIII-IDD,CORNERS:-DDIIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIII-IDD,CORNERS:-DDIIIII,CENTERS:DDDDDD"
/>
So the only cases left are the ones with both pieces in the F2L slots, what about those? Bar a few good cases, it's not recommended to learn them. Why? Because when these cases appear in a solve, there's a very high chance that there will be another F2L pair on the cube that's more efficient and faster to solve, so we could just choose that pair instead. This is called [Pair Choice](/improvement-guide/zzf2l/pair-choice).
diff --git a/pages/fr/tutorial/eo.mdx b/pages/fr/tutorial/eo.mdx
index fb8535e..a1b6463 100644
--- a/pages/fr/tutorial/eo.mdx
+++ b/pages/fr/tutorial/eo.mdx
@@ -46,8 +46,7 @@ Almost! This is the closest we can get, usually something like this:
@@ -89,8 +88,7 @@ Here we have a green-red edge. Let's press ▶️ and watch the green sticker, s
@@ -130,8 +126,7 @@ For example, this bad edge has a red sticker in the purple orbit, and a green st
@@ -192,8 +186,7 @@ After that, we can choose how to hold the cube. For example, orange center top,
@@ -210,8 +203,7 @@ Edges with those stickers are bad.
@@ -227,8 +219,7 @@ We found three bad edges so far, let's mark them with tape.
@@ -259,8 +249,7 @@ We've found all 6 bad edges! Here they are.
@@ -329,8 +317,7 @@ With `F2`, it's much simpler:
diff --git a/pages/fr/tutorial/eocross.mdx b/pages/fr/tutorial/eocross.mdx
index da30e49..68ab6a9 100644
--- a/pages/fr/tutorial/eocross.mdx
+++ b/pages/fr/tutorial/eocross.mdx
@@ -20,10 +20,8 @@ A solved EOCross looks like this:
@@ -83,11 +81,10 @@ Then we can do `R'`.
Now we know how to move any cross edge to the bottom.
@@ -95,11 +92,10 @@ We could put all cross edges on the bottom, and it would look like this.
However, this is not a solved cross!
@@ -107,10 +103,8 @@ Our goal is to solve the cross pieces, which looks something like this:
@@ -130,12 +124,11 @@ Here's an example where we use these relationships to solve cross:
There are already two cross edges at the bottom, but they don't have the right relationship.
@@ -146,11 +139,10 @@ We can fix that by replacing the green-white cross edge with the blue-white cros
Move: `R`
@@ -163,11 +155,10 @@ We can do `D2 R'` to place the blue cross edge opposite to the green cross edge,
@@ -176,11 +167,10 @@ We can finish with `D L'`.
diff --git a/pages/fr/tutorial/ll.mdx b/pages/fr/tutorial/ll.mdx
index 76b93fb..db834b2 100644
--- a/pages/fr/tutorial/ll.mdx
+++ b/pages/fr/tutorial/ll.mdx
@@ -47,10 +47,9 @@ An important pattern for OCLL recognition is called **headlights:** a pair of ma
@@ -80,10 +79,9 @@ Like in OCLL, we look for headlights, but they look a bit different:
diff --git a/pages/fr/tutorial/zzf2l.mdx b/pages/fr/tutorial/zzf2l.mdx
index 6514f89..5362e55 100644
--- a/pages/fr/tutorial/zzf2l.mdx
+++ b/pages/fr/tutorial/zzf2l.mdx
@@ -32,23 +32,19 @@ The rest of the article does not require any knowledge of CFOP.
To complete the F2L, we need to solve four corners and four edges around the EOCross.
Each pair of matching corners and edges is called an **F2L pair**. For example, this is the front-right (FR) pair, scrambled up:
And that "gap" where a pair belongs to is called an **F2L slot**. So the FR pair belongs to the FR slot, shown above as an empty spot.
@@ -69,11 +65,9 @@ We call these two simplest ways **basic inserts**.
This is the **joined pair:** the two pieces of this F2L pair are joined together with the colors aligned.
Moves: `R U' R'`
@@ -92,11 +86,9 @@ This is the **split pair:** it looks like a joined pair that was split apart by
We can also solve this in three moves with this strategy:
Moves: `R U R'`
@@ -117,11 +109,9 @@ Here's the same F2L case on both the FR and FL pairs.
Front-right pair:
Moves: `R U2 R'`
@@ -129,11 +119,9 @@ Front-right pair:
Front-left pair:
@@ -166,10 +154,9 @@ To move a trapped piece to the top, we'll learn a general strategy.
As an example, the white-blue-orange corner is trapped in the FR slot.
Moves: `R U R'`
@@ -181,10 +168,9 @@ As an example, the white-blue-orange corner is trapped in the FR slot.
This strategy still works if both F2L pieces are trapped in the same slot:
Moves: `R U R'`
@@ -193,10 +179,9 @@ However, if exactly one piece is already at the top, there's a chance that it wi
For example, doing `R U R'` here will just trap the corner.
Moves: `R U R'`. Oh no, corner's trapped now!
@@ -208,10 +193,9 @@ Here, the first move is `R`, so then we move the pieces out of the R layer.
`U2` works. You could also do `U'`.
Moves: `R'`**`U2`**`R'`
@@ -225,10 +209,9 @@ This BR pair has both pieces trapped.
Let's lift the edge to the top.
@@ -241,10 +224,9 @@ Let's lift the edge to the top.
Then we can lift the corner to the top, but be careful because we now have the edge at the top.
@@ -263,21 +245,19 @@ The pair is now at the top, but if they're "touching" then we want to separate t
The pair is **touching** if they're right next to each other like this:
This pair is separated, which is what we want:
To separate a touching pair, there are four easy moves:
@@ -295,10 +275,9 @@ For example, in this situation we can do:
4. `R'` to move the FR slot back down.
Moves: `U R U2 R'`
@@ -309,10 +288,9 @@ For example, in this situation we can do:
Here's the FL pair, the pieces are touching and the BL slot is also unsolved.
@@ -344,10 +322,9 @@ We'll setup a joined pair.
Here's the strategy alongside an example:
Moves: `U2 R U R'`
@@ -365,10 +342,9 @@ Then we'll have a joined pair.
Here's the FL pair, the corner has the white D sticker on the top side so it's Case A.
@@ -393,10 +369,9 @@ The **hiding spot** for the corner is the position that is an `R2` or `L2` move
Here's the strategy for Case B:
Moves: `U' R U2 R'`
@@ -414,10 +389,9 @@ Now we'll have a joined pair!
This is the BL pair. Both pieces have green on the top, so this is Case B.
@@ -445,20 +419,18 @@ The split pair is also like this, so we'll set up to the split pair.
There are only two cases. It's either a split pair which is our goal (you can see that it's 1 move away from being joined).
Or, it's not a split pair. We'll follow a strategy very similar to Case B.
Moves: `U' R U R'`
@@ -482,10 +454,9 @@ Imagine we did an `R2`. That position would move to the top-front-right.
That's the hiding spot.
Moves: `U2 R' U' R`
@@ -512,10 +483,9 @@ The FR slot is in the R layer, so we can do a `U2` to move the pair out of the R
`U'` also works.
@@ -526,11 +496,9 @@ Now it's time to do the basic insert. Here's the explanation from the [basic ins
3. Bring the solved slot back down. (`R'`)
Moves: `R U' R'`
@@ -538,11 +506,9 @@ Now it's time to do the basic insert. Here's the explanation from the [basic ins
Alternatively, if we chose `U'` instead of `U2` to position the pair, our basic insert will be like this:
Moves: `R U2 R'`
@@ -557,21 +523,18 @@ The corner needs to be above the slot we're solving, and that's the only positio
In this case, do a `U'` to move the corner above the FR slot, which the pair belongs to.
Now it's time to do the basic insert. Here's the explanation from the [basic inserts section](/tutorial/zzf2l#basic-inserts) again:
Moves: `R U R'`
diff --git a/pages/globals.css b/pages/globals.css
new file mode 100644
index 0000000..b5c61c9
--- /dev/null
+++ b/pages/globals.css
@@ -0,0 +1,3 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
diff --git a/pages/he/about.mdx b/pages/he/about.mdx
deleted file mode 100644
index c019287..0000000
--- a/pages/he/about.mdx
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: About
-description: About zzmethod.com
-author: crystalcuber
----
-
-import PetGallery from "components/PetGallery";
-
-ZZMethod.com is the modern, complete guide to the ZZ Method.
-
-## Modern
-
-ZZ has evolved since its proposal in 2003. In recent years, EOCross has become the dominant EO step, but resources have not caught up. This website is the first to fully document "Modern ZZ", the way it is practiced now.
-
-We present an innovative EO tutorial that makes EO intuitive and easy to learn. It goes beyond stating the rules of how to solve it, by showing how the rules emerge from a simple concept. It uses animated 3D cubes from [`cubing.js`](https://js.cubing.net/cubing/twisty/) to visualize how EO works.
-
-## Complete
-
-This site has everything needed to excel with modern ZZ. We have an in-depth tutorial walking through each step of the method.
-
-We feature a very comprehensive improvement guide written by [Yoruba](https://youtube.com/@yoruba7807), a sub-8 ZZ solver. It covers advanced techniques and practical advice for improving with the method.
-
-Modern ZZ has been difficult to learn because key resources were scattered or didn't exist. We are filling the gap, inspired by the classic tutorials of [Conrad Rider](http://cube.rider.biz/zz.php) and [Phil Yu](https://youtube.com/playlist?list=PLD9771CF83F13B110).
-
-## How you can help
-
-As an open-source project, this site relies on contributions to stay modern and become more complete. If you'd like to help, check out our [GitHub](https://github.com/ericx20/zz-method-docs)!
-
-## ZZ Pet Gallery
-
-Here are some pets from ZZ solvers around the world:
-
-
-
-You can submit yours [here](https://forms.gle/6R2gSi1zX2tSknLUA).
diff --git a/pages/he/blog.mdx b/pages/he/blog.mdx
deleted file mode 100644
index 33f5b2b..0000000
--- a/pages/he/blog.mdx
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: ZZ Blog
-description: A helpful blog written by ZZ solvers.
----
-
-import Blog from "components/Blog";
-
-
diff --git a/pages/he/blog/_meta.tsx b/pages/he/blog/_meta.tsx
deleted file mode 100644
index 09a35f5..0000000
--- a/pages/he/blog/_meta.tsx
+++ /dev/null
@@ -1,12 +0,0 @@
-export default {
- "*": {
- "display": "hidden",
- "theme": {
- "toc": false,
- "sidebar": false,
- "pagination": false
- }
- },
- "story": "The story of ZZMethod.com",
- "zz-example-solve-library": "Introducing ZZ Example Solve Library!"
-}
diff --git a/pages/he/blog/story.mdx b/pages/he/blog/story.mdx
deleted file mode 100644
index 5b9431b..0000000
--- a/pages/he/blog/story.mdx
+++ /dev/null
@@ -1,112 +0,0 @@
----
-title: The story of ZZMethod.com
-description: Learn more about the creation of this site.
-author: crystalcuber, Swagrid, yoruba
-date: Feb 9th, 2024
----
-
-import TwistyPlayer from "components/TwistyPlayer";
-
-## How it started
-
-Over the past several years, the ZZ method has evolved significantly. Solvers are now preferring EOCross over EOLine, and ZBLL is gaining popularity.
-We found very few resources for this new style of ZZ.
-They were scattered across the web, making it more difficult to learn and master the method.
-In September of 2023, we decided to start working on a solution to this problem. We wanted to build a central website that would explain the basics of ZZ and how to improve with it.
-We took inspiration from the trail-blazing tutorials by ZZ legends
-[Conrad Rider](http://cube.rider.biz/zz.php) and [Phil Yu](https://www.youtube.com/watch?v=Q9f-uHyHeQs&list=PLD9771CF83F13B110).
-
-## The team
-
-We are a team of friends and volunteers who enjoy the ZZ Method.
-Here are the three initial contributors:
-
-- [crystalcuber](https://www.youtube.com/@crystalcuber) is a software engineer and cube resource developer.
-- [Yoruba](https://www.youtube.com/@yoruba7807) is a speedcuber, known for being the fastest ZZ user.
-- [S1neWav\_](https://www.youtube.com/@S1neWav_) is a speedcuber and ZZ user who knows full ZBLL.
-
-## Building the website
-
-We used a tool called [Nextra](https://nextra.site/) to generate the site for us.
-It provides the basic UI of the site, allowing us to focus on writing the articles.
-Nextra is usually used to make documentation for software, but it worked great for documenting Rubik's cube methods too!
-
-## Writing the content
-
-We began writing the content around September of 2023, with the goal of releasing by Halloween.
-
-crystalcuber started working on a tutorial section for learning each step of the method.
-At the same time, Yoruba started writing articles for how to improve at each step.
-However, we realized it was going to take much longer than expected.
-
-The EO tutorial was based on crystalcuber's existing [video tutorial](https://www.youtube.com/watch?v=fxwVmTI5nGM) which saved a lot of time.
-However, it was a challenge to replicate the visuals of the video within the written version.
-We needed to create interactive 3D cubes that would show how EO worked.
-Thankfully, [`cubing.js`](https://js.cubing.net/cubing/) is an amazing tool that helped us build these visualizations.
-
-
-
-In the meantime, Yoruba created an ambitious list of 15 topics he wanted to cover for the improvement guide.
-Then, he started writing articles at a breakneck speed, with the quality never faltering.
-Yoruba wrote step-by-step instructions for improving skill at each step of the method, from EOCross and ZZF2L techniques to advice for learning ZBLL.
-He also shared his practice drills for targeting specific skills.
-
-Despite the rapid progress, the project proved too large to make the initial launch date, and we had to delay the release by a month.
-The new target date was November 26th, giving S1neWav\_ some time during his holidays to contribute.
-
-Our friend and YouTuber [Swagrid](https://www.youtube.com/@SwagridCubing/) filmed the video _How to master the ZZ method_ where he graciously promoted our project.
-We all worked together to coordinate the simultaneous release of both projects on the 26th.
-
-Yoruba went full steam ahead and completed most of the improvement guide.
-The tutorial section needed some help however, because ZZF2L was proving to be a challenge to explain.
-We wanted our site to have a dedicated ZZF2L tutorial that did not base its explanation on CFOP F2L.
-It needed to be accessible to cubers who did not have a foundation in CFOP.
-S1neWav\_ stepped in and created an intuitive beginner ZZF2L method.
-He also wrote an outline for the Last Layer tutorial, choosing to teach beginners OCLL and 2-look PLL.
-
-For a second time, we started running out of time before our new launch day.
-We were close enough to the end that we only needed to delay its release by one week.
-We completed the improvement guide and the beginner tutorial, adding some finishing touches.
-
-## Launch
-
-On December 4th, 2023 we shared our website with the world.
-
-Swagrid released his [_How to MASTER the ZZ Method_ video](https://www.youtube.com/watch?v=vNgkGSNssxE) after delaying it for over a month just for us.
-The video performed well for both of us: Swagrid earned a new wave of subscribers and our site experienced a massive spike of initial traffic.
-
-We got a lot of feedback from online ZZ users, and we spent some time adding their suggestions.
-Overall, the website was well-received.
-It was great to start seeing people send ZZMethod.com links whenever someone asked for help with ZZ.
-
-## Gratitude
-
-We want to give a big thanks to everyone who helped us along the way!
-
-Thank you [Lucas Garron](https://garron.net/) for the `cubing.js` library.
-The TwistyPlayer visualizer enabled us to build highly visual tutorials and resources with ease.
-Thanks for continuing to maintain and improve the library, and directly giving us help using it.
-
-[Athefre](https://sites.google.com/site/athefre), thank you for your eye-opening research on the [origins of methods](https://www.cubinghistory.com/), including the ZZ method.
-It helped us write a more accurate introduction to ZZ.
-
-Thanks [Swagrid](https://www.youtube.com/@SwagridCubing/) for promoting our website on your YouTube channel.
-You even delayed your own upload just for us.
-
-Shoutout to [Gen The Snail](https://www.youtube.com/@GenTheSnail) and [Fahmi Aulia Rachman](https://www.youtube.com/@UNOFahmiAR) for your suggestions to improve the site.
-
-Thank you Bas for adding us to [speedcubing.com](https://speedcubing.com/CubingTutorials.html).
-
-And finally, thanks to many online users who offer feedback and are sharing our work with others.
-It makes us happy to see our resources being used to help people across various forums and social media.
-
-## What's next?
-
-We're planning to add more blog posts and more resources.
-Stay tuned!
diff --git a/pages/he/blog/zz-example-solve-library.mdx b/pages/he/blog/zz-example-solve-library.mdx
deleted file mode 100644
index 7bc84aa..0000000
--- a/pages/he/blog/zz-example-solve-library.mdx
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title: Introducing ZZ Example Solve Library!
-description: A new, practical resource to learn from the best ZZ solvers.
-author: crystalcuber
-date: July 28th, 2024
----
-
-import { Callout } from "nextra/components";
-import { ReconViewer } from "components/ReconViewer";
-import { RECONS, YOUTUBE_VIDEO_ID } from "reconstructions/he/yoruba-7.19-ao50";
-import YouTubeEmbed from "components/YouTubeEmbed";
-
-
-
-We're excited to announce our ZZ Example Solve Library!
-It's a collection of solves from the best ZZ solvers for learning and inspiration.
-
-## Why do we need example solves?
-
-No matter if you use CFOP, Roux or ZZ, example solves are an essential resource to improve as a cuber.
-Solutions, fingertricks and techniques can get complicated because there are so many ways to do the same thing.
-Example solves show you how highly skilled cubers approach it.
-
-Unfortunately, ZZ has always had a lack of example solves.
-There aren't a lot of ZZ users, and the method has evolved a lot in the past 5 years.
-It's hard to find solves using recent trends such as EOCross and ZBLL.
-
-## What is ZZ Example Solve Library?
-
-[Example Solve Library](/example-solves) is a new section on this website dedicated to ZZ solve reconstructions.
-Each collection of solves includes a video and a full, move-by-move breakdown of the solutions.
-For example, this is what a solve by Yoruba looks like:
-
-
-
-
-
-## Yoruba's 7.19 Ao50
-
-We're launching the Library with 50 solves from Yoruba, the fastest ZZ user and author of the [Improvement Guide](/improvement-guide).
-
-
- Check out [Yoruba's 50 example solves!](/example-solves/yoruba-7.19-ao50)
-
-
-If you're interested in contributing to the library, learn [how to submit your solves here](/example-solves#submissions).
diff --git a/pages/he/example-solves.mdx b/pages/he/example-solves.mdx
deleted file mode 100644
index 3857ace..0000000
--- a/pages/he/example-solves.mdx
+++ /dev/null
@@ -1,83 +0,0 @@
----
-title: ZZ Example Solve Library
-description: A collection of ZZ example solves to learn from.
-author: crystalcuber
----
-
-import { Cards } from "nextra/components";
-import logo from "public/logo.svg";
-import logoEOCross from "public/logo-eocross.svg";
-import Image from "next/image";
-
-Welcome to our collection of modern ZZ solves!
-Example solves are an essential learning resource for any method.
-You can see real-world examples of:
-
-- Finger tricks
-- EOCross solutions
-- F2L solutions and pair choice
-- LL algs and execution
-
-All of our solves are filmed at a suitable camera angle and reconstructed move-by-move.
-Some include helpful notes and alternative solutions by the solvers themselves.
-The reconstructions are brought to life with 3D animations by [`cubing.js`](https://js.cubing.net/cubing/twisty/).
-
-## Collections
-
-We currently have 159 solves from five ZZ solvers. Check them out!
-
-
- }
- title="Yoruba's 5.86 ao5"
- href="/example-solves/yoruba-5.86-ao5"
- />
- }
- title="Yoruba's 6.65 ao25"
- href="/example-solves/yoruba-6.65-ao25"
- />
- }
- title="Yoruba's 7.19 ao50"
- href="/example-solves/yoruba-7.19-ao50"
- />
- }
- title="Yoruba's Advanced Examples"
- href="/example-solves/yoruba-advanced-example-25"
- />
- }
- title="Gen's 8.99 official ao5"
- href="/example-solves/gen-8.99-ao5"
- />
- }
- title="Gen's 11.68 official OH ao5"
- href="/example-solves/gen-11.68-oh-ao5"
- />
- }
- title="Luna's 9.00 ao25"
- href="/example-solves/luna-9.00-ao25"
- />
- }
- title="Jouda's 11.26 OH ao5"
- href="/example-solves/jouda-11.26-oh-ao5"
- />
- }
- title="rouxzzcfop's 7.64 ao12"
- href="/example-solves/rouxzzcfop-7.64-ao12"
- />
-
-
-## Submissions
-
-If you're interested in adding your ZZ solves to the library, let us know by submitting an [issue on GitHub](https://github.com/ericx20/zz-method-docs/issues).
-
-- Please include a video of the solves, which may be official or unofficial.
-- We'll review your submission for quality.
-- If approved, we will ask for solve reconstructions.
diff --git a/pages/he/example-solves/_meta.tsx b/pages/he/example-solves/_meta.tsx
deleted file mode 100644
index aae9e80..0000000
--- a/pages/he/example-solves/_meta.tsx
+++ /dev/null
@@ -1,11 +0,0 @@
-export default {
- "yoruba-5.86-ao5": "Yoruba's 5.86 ao5",
- "yoruba-6.65-ao25": "Yoruba's 6.65 ao25",
- "yoruba-7.19-ao50": "Yoruba's 7.19 ao50",
- "yoruba-advanced-example-25": "Yoruba's Advanced Examples",
- "gen-8.99-ao5": "Gen's 8.99 ao5",
- "gen-11.68-oh-ao5": "Gen's OH 11.68 ao5",
- "luna-9.00-ao25": "Luna's 9.00 ao25",
- "jouda-11.26-oh-ao5": "Jouda's OH 11.26 ao5",
- "rouxzzcfop-7.64-ao12": "rouxzzcfop's 7.64 ao12"
-}
diff --git a/pages/he/example-solves/gen-11.68-oh-ao5.mdx b/pages/he/example-solves/gen-11.68-oh-ao5.mdx
deleted file mode 100644
index f4d94b9..0000000
--- a/pages/he/example-solves/gen-11.68-oh-ao5.mdx
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Gen's 11.68 One-Handed Average of 5
-description: Learn from 5 official OH ZZ solves by Gen.
-author: Gen, crystalcuber
----
-
-import { ReconCollection } from "components/ReconCollection";
-import { RECONS, YOUTUBE_VIDEO_ID } from "reconstructions/he/gen-11.68-oh-ao5";
-
-Here are five official one-handed solves by Gen, done at NAC 2024.
-She achieved 9th place in semifinals with this 11.68 ao5.
-She uses EOLine and full ZBLL.
-
-
-
-
diff --git a/pages/he/example-solves/gen-8.99-ao5.mdx b/pages/he/example-solves/gen-8.99-ao5.mdx
deleted file mode 100644
index 73f0aaa..0000000
--- a/pages/he/example-solves/gen-8.99-ao5.mdx
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Gen's 8.99 Average of 5
-description: Learn from 5 official ZZ solves by Gen.
-author: Gen, crystalcuber
----
-
-import { ReconCollection } from "components/ReconCollection";
-import { RECONS, YOUTUBE_VIDEO_ID } from "reconstructions/he/gen-8.99-ao5";
-
-Here are five official solves by Gen, done at NAC 2024.
-She is the 5th ever person to achieve an official ZZ sub-9 average.
-She uses EOLine and full ZBLL.
-
-
-
-
diff --git a/pages/he/example-solves/jouda-11.26-oh-ao5.mdx b/pages/he/example-solves/jouda-11.26-oh-ao5.mdx
deleted file mode 100644
index 8b016d9..0000000
--- a/pages/he/example-solves/jouda-11.26-oh-ao5.mdx
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Jouda's 11.26 One-Handed Average of 5
-description: Learn from 5 OH ZZ solves by Jouda.
-author: Jouda
----
-
-import { ReconCollection } from "components/ReconCollection";
-import { RECONS, YOUTUBE_VIDEO_ID } from "reconstructions/he/jouda-11.26-oh-ao5";
-
-Here are five one-handed ZZ solves by Jouda with reconstructions.
-Jouda uses EOCross and OCLL/PLL, with T and U ZBLL.
-
-
-
-
diff --git a/pages/he/example-solves/luna-9.00-ao25.mdx b/pages/he/example-solves/luna-9.00-ao25.mdx
deleted file mode 100644
index 3db4042..0000000
--- a/pages/he/example-solves/luna-9.00-ao25.mdx
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: Luna's 9.00 Average of 25
-description: Learn from 25 example ZZ solves by Yoruba.
-author: Luna
----
-
-import { ReconCollection } from "components/ReconCollection";
-import { RECONS, YOUTUBE_VIDEO_ID } from "reconstructions/he/luna-9.00-ao25";
-
-Here is Luna's 9.00 ao25, fully reconstructed! They use EOCross and ZBLL except sunes.
-
-- Average movecount: 55.32 STM
-- Average TPS: 6.03
-
-
-
-
-
-## Self-Critique
-
-### Pros
-
-1. In general my solutions here for both EOCross and F2L are solid. I messed up occasionally but I mostly had good, efficient, and ergonomic solutions.
-2. I have overall good efficiency. With the exception of a couple solves where I messed up, most of the solves were in the 48-54 range for movecount, which is good.
-
-### Cons
-
-1. I have awful F2L lookahead, I need to get better at looking away from the pair I'm solving. I usually pause between first and second pair.
-2. I'm bad at finding pieces. This connects again to lookahead. I'm frequently looking to the back when I should be remembering what's in there or deducing it.
-3. Some of my ZBLLs need more drilling. I should revise my algs and learn to predict AUF for the cases I don't know how to.
-
-### Solutions
-
-1. Do untimed solves focusing on making my F2L as smooth as possible.
-2. Drill ZBLL more, especially the cases I'm struggling with.
-3. Practice piece deduction using Conrad Rider's drill
diff --git a/pages/he/example-solves/rouxzzcfop-7.64-ao12.mdx b/pages/he/example-solves/rouxzzcfop-7.64-ao12.mdx
deleted file mode 100644
index 7482398..0000000
--- a/pages/he/example-solves/rouxzzcfop-7.64-ao12.mdx
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: rouxzcfop's 7.64 Average of 12 (6.98 ao5)
-description: Learn from 50 example ZZ solves by rouxzzcfop.
-author: rouxzzcfop
----
-
-import { ReconCollection } from "components/ReconCollection";
-import { RECONS, YOUTUBE_VIDEO_ID } from "reconstructions/he/rouxzzcfop-7.64-ao12";
-
-I did not expect to record such a nice ao5.
-The ao12 is more or less representative of my current average.
-I've included two extra solves at the end because they were a bit... interesting.
-
-- Mean STM: 56.9
-- Mean time: 8.23
-- Mean TPS: 6.91
-
-
-
-
diff --git a/pages/he/example-solves/yoruba-5.86-ao5.mdx b/pages/he/example-solves/yoruba-5.86-ao5.mdx
deleted file mode 100644
index 73b3cce..0000000
--- a/pages/he/example-solves/yoruba-5.86-ao5.mdx
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: Yoruba's 5.86 Average of 5
-description: Learn from 5 example ZZ solves by Yoruba.
-author: Gen, Yoruba
----
-
-import { ReconCollection } from "components/ReconCollection";
-import { RECONS, YOUTUBE_VIDEO_ID } from "reconstructions/he/yoruba-5.86-ao5";
-
-Check out this 5.86 ao5 by Yoruba, including a 5.32 mo3.
-He uses EOCross and ZBLL except sunes.
-
-- Average movecount: 50.40 STM
-- Average TPS: 8.47
-
-
-
-
diff --git a/pages/he/example-solves/yoruba-6.65-ao25.mdx b/pages/he/example-solves/yoruba-6.65-ao25.mdx
deleted file mode 100644
index bf4ba54..0000000
--- a/pages/he/example-solves/yoruba-6.65-ao25.mdx
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: Yoruba's 6.65 Average of 25
-description: Learn from 25 example ZZ solves by Yoruba.
-author: Gen, Yoruba
----
-
-import { ReconCollection } from "components/ReconCollection";
-import { RECONS, YOUTUBE_VIDEO_ID } from "reconstructions/he/yoruba-6.65-ao25";
-
-We present a 6.65 ao25 by Yoruba with full reconstructions. It's a significant improvement over the 7.19 ao50.
-He uses EOCross and ZBLL except sunes.
-
-- Average movecount: 55.68 STM
-- Average TPS: 8.31
-
-
-
-
diff --git a/pages/he/example-solves/yoruba-7.19-ao50.mdx b/pages/he/example-solves/yoruba-7.19-ao50.mdx
deleted file mode 100644
index 0756bb0..0000000
--- a/pages/he/example-solves/yoruba-7.19-ao50.mdx
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: Yoruba's 7.19 Average of 50
-description: Learn from 50 example ZZ solves by Yoruba.
-author: Yoruba, crystalcuber, Jouda, Fahmi
----
-
-import { ReconCollection } from "components/ReconCollection";
-import { RECONS, YOUTUBE_VIDEO_ID } from "reconstructions/he/yoruba-7.19-ao50";
-
-This is a collection of 50 ZZ solves by Yoruba, complete with reconstructions.
-He uses EOCross and ZBLL except sunes.
-
-- Average movecount: 55.42 STM
-- Average TPS: 7.73
-
-
-
-
diff --git a/pages/he/example-solves/yoruba-advanced-example-25.mdx b/pages/he/example-solves/yoruba-advanced-example-25.mdx
deleted file mode 100644
index d193c62..0000000
--- a/pages/he/example-solves/yoruba-advanced-example-25.mdx
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Yoruba's Advanced Example Solves
-description: Learn from 25 advanced example ZZ solves by Yoruba.
-author: Yoruba
----
-
-import { ReconCollection } from "components/ReconCollection";
-import { RECONS } from "reconstructions/he/yoruba-advanced-example-25";
-
-Here are 25 advanced example solves from Yoruba (EOCross + ZBLL except sunes).
-They aren't timed, and are walkthroughs of what he would do in a real solve plus some minor optimizations.
-This is a great resource for learning techniques and tricks in EOCross and ZZF2L.
-
-
-
-
diff --git a/pages/he/improvement-guide.mdx b/pages/he/improvement-guide.mdx
deleted file mode 100644
index 6541481..0000000
--- a/pages/he/improvement-guide.mdx
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: ZZ Improvement Guide
-description: The comprehensive guide to solving faster with the ZZ Method.
-author: crystalcuber
----
-
-Welcome to the Modern ZZ Improvement Guide.
-We have comprehensive articles for advanced techniques, practice tips and general advice so you can reach your potential!
-
-1. [EOCross guide](/improvement-guide/eocross)
-2. [ZZF2L guide](/improvement-guide/zzf2l)
-3. [LL guide](/improvement-guide/ll)
diff --git a/pages/he/improvement-guide/_meta.tsx b/pages/he/improvement-guide/_meta.tsx
deleted file mode 100644
index 9d0595b..0000000
--- a/pages/he/improvement-guide/_meta.tsx
+++ /dev/null
@@ -1,5 +0,0 @@
-export default {
- "eocross": "Improve EOCross",
- "zzf2l": "Improve ZZF2L",
- "ll": "Improve Last Layer"
-}
diff --git a/pages/he/improvement-guide/eocross/_meta.tsx b/pages/he/improvement-guide/eocross/_meta.tsx
deleted file mode 100644
index 3e076cc..0000000
--- a/pages/he/improvement-guide/eocross/_meta.tsx
+++ /dev/null
@@ -1,8 +0,0 @@
-export default {
- "eocross-full-guide": "EOCross Full Guide",
- "color-neutrality": "Color neutrality",
- "efficiency": "Efficiency",
- "practicing": "How to practice",
- "inspection": "Planning in inspection",
- "xeocross": "XEOCross"
-}
diff --git a/pages/he/improvement-guide/eocross/efficiency.mdx b/pages/he/improvement-guide/eocross/efficiency.mdx
deleted file mode 100644
index 88fea71..0000000
--- a/pages/he/improvement-guide/eocross/efficiency.mdx
+++ /dev/null
@@ -1,89 +0,0 @@
----
-title: How to solve EOCross efficiently
-description: A guide to saving moves during EOCross in the ZZ Method.
-author: yoruba
----
-
-For the mainstream methods, a strategy for solving intuitive steps is to break them into 2 easier to manage steps. Then as you get more skilled, you will begin to find ways to merge both of these steps into one.
-
-In the CFOP method for example, less experienced solvers might plan 2-3 cross edges at once, and then solve the rest of the cross. Or in the Roux method with the first block, solvers choose between various approaches depending on the scramble: mainly square+pair, line+other line or F2L style.
-
-In ZZ, the main approaches are:
-
-1. EO+2 -> the rest. This is where you solve your EO and any of the 2 cross edges at the same time, and then solve the rest of the cross edges. The EO+2 step should influence the last 2 edges as much as possible (most commonly used, for 0, 2, 4, and 6-flips). \
- [Example 1](https://alpha.twizzle.net/edit/?setup-alg=R2+B2+U%27+B2+L2+D+R2+D2+R2+U%27+L2+R%27+U+L+B%27+D%27+F2+R+F%27+D+F&alg=R%27+B+F+R+U+F+%2F%2F+EO%2B2%0AL+R+%2F%2F+finish&stickering=EOcross), [Example 2](https://alpha.twizzle.net/edit/?setup-alg=F2+D+F2+R2+D2+F2+R2+D%27+B2+D%27+L2+R%27+D+R2+F2+R+B2+F+U+F2+R%27&alg=F+R+U%27+F+%2F%2FEO%2B2%0AL%27+D+L+%2F%2Ffinish&stickering=EOcross)
-
-2. Partial EO+2 -> solve the other 2 while finishing EO. In this approach, you orient some, but not all of the edges while solving 2 of the cross edges, and then you orient the remaining edges and solve the remaining cross pieces. (Most commonly used for higher n-flips: with 6+ bad edges). \
- [Example](https://alpha.twizzle.net/edit/?setup-alg=F2+D2+L2+B2+L2+F2+D%27+L2+B2+L%27+U%27+R%27+F%27+L%27+F%27+D+L+U+B%27&alg=B%27+%2F%2FPartial+EO+%2B+2%0AF%27+D%27+F+L2+%2F%2Ffinish&stickering=EOcross), [Example 2](https://alpha.twizzle.net/edit/?setup-alg=R+F2+L+U2+R%27+F2+D2+L+U2+R+U2+R2+F+D%27+F%27+L%27+U2+F%27+D2+U%27+R&alg=F%27+%2F%2FPartial+EO+%2B2+edges%0AD%27+R%27+D%27+F+R+D2+%2F%2Ffinish&stickering=EOcross)
-
-3. Cross > EO. Here you solve the cross pieces first, and then orient the edges. (This is by far used the rarest, and is only really used in 2-flips from time to time when you can cancel into a sledge at the end). \
- [Example](https://alpha.twizzle.net/edit/?setup-alg=D%27+L2+R2+U2+B+D+B+U+B+D2+R%27+U%27+D+B%27+R%27+L%27+U%27+R+L2+U%27+B%27+D+U2+B+R&alg=B2+R2+D2+%2F%2F+solving+the+cross+edges%0AF+R+F%27+%2F%2Fcancelling+into+EO&stickering=EOcross)
-
-## Influencing
-
-**Influencing** is about affecting the cross pieces during the EO solution, to get a better cross.
-You should learn these fundamental influencing techniques:
-
-- Using different directions for F/B moves
-
- - Easiest example: Solving the edge directly: \
- [Example](https://alpha.twizzle.net/edit/?alg=B%27+U+R+%2F%2F+orient+4+%2B+solve+1+edge%0AF+%2F%2F+orients+4+edges.+The+F+move+also+directly+solve+the+cross+edge%2C+instead+of+F%27+%0AR+L2+D%27+%2F%2F+finish&stickering=EOcross&setup-alg=B2+L%27+R%27+F2+D2+F2+D2+B2+L%27+R2+B2+U+F+L%27+B%27+D+F+D%27+U%27+R+U2)
-
- - Inserting other cross edges: \
- [Example 1](https://alpha.twizzle.net/edit/?setup-alg=R2+F2+U+B2+R2+B2+U2+L2+F2+R+F2+U+F2+D2+B+R'+L2+D2&alg=U+R'+%2F%2F+bringing+the+4+bad+edges.%0AF+%2F%2F+inserting+the+green+cross+edge+instead+of+orange%0AU+L2+%2F%2F+finish&stickering=EOcross), [Example 2](https://alpha.twizzle.net/edit/?setup-alg=D2+L2+U+R2+F2+U+R2+D+L2+R2+U2+B+D%27+R%27+D+R%27+F2+R2+B2+L%27+D%27&alg=L+R2+U+%2F%2F+bringing+4+bad+edges%0AF+%2F%2F+if+you+do+F%27%2C+it+would+incorectly+put+the+red+cross+edge+relative+to+the+green+and+blue+ones.+Inserting+the+orange+cross+edge+is+a+better+option.%0AU%27+D%27+R2+%2F%2F+finish&stickering=EOcross)
-
-- Switching the bad edges you're going to orient \
- [Example](https://alpha.twizzle.net/edit/?setup-alg=U%27+R2+U%27+L2+U+B2+U+B2+D+R%27+B+U+R+L+B2+L2+U%27+B%27+U&alg=U%27+D%27+%2F%2F+switching+out+the+bad+edges%3A+we+already+had+4+on+B%2C+and+we+want+to+do+B%27+%28to+insert+the+blue+cross+edge%29.+We+can+move+the+red+and+orange+edges+to+the+B+face+so+that+after+B%27%2C+they+get+put+in+their+respective+layers.%0AB%27+%2F%2F+Orienting+4.+Now+the+red+and+orange+cross+edges+get+put+in+their+respective+layers.%0AR+U%27+F%27+L%27+%2F%2F+finish&stickering=EOcross)
-
-- Doing extra moves before an EO turn (replacement technique) \
- [Example 1](https://alpha.twizzle.net/edit/?setup-alg=D2+B%27+R2+D2+B2+D%27+R2+U+B2+L2+R2+U2+F%27+L+U%27+F%27+L2+D2+U+R%27&alg=B%27+D%27+%2F%2F+orient+4%0AL+%2F%2F+if+we+do+that+before+EO...%0AF2+R%27+F+%2F%2F+...we+solve+the+red+cross+edge+as+well.%0AL2+%2F%2F+finish&stickering=EOcross), [Example 2](https://alpha.twizzle.net/edit/?setup-alg=R2+B2+U2+B+U2+B%27+U2+F2+L+D+U%27+F%27+R%27+F%27+D2+F2+R%27+B%27&alg=L+%2F%2F+before+EO%2C+we+already+have+4+bad+edges+on+the+B+face%2C+but+L+puts+a+cross+edge+and+orients+an+otherwise+problematic+DL+bad+edge.%0AB%27+U%27+F+%2F%2F+EO%2B2%0AR+D+L+D+%2F%2F+finish&stickering=EOcross)
-
-- Handling cases with 2 bad edges on the F/B faces, where you manipulate the position of EO. For this Learn how EO gets changed, as well how it affects the cross pieces
-
- - Adjacent 2 bad edges: \
- [Example 1](https://alpha.twizzle.net/edit/?setup-alg=D+B2+L+D2+F2+R2+U2+R%27+D2+B2+U2+F%27+U+B2+U+D%27+R%27+B%27+L%27+F2&alg=R%27+B%27+R+D+%2F%2F+partialEO%2B3+edges%0AF%27+%2F%2F+2+adjacent+bad+edges%2C+changes+the+position+of+EO%0AU2+R%27+F%27+%2F%2F+putting+the+bad+edges+and+orienting%0AR+%2F%2F+finish&stickering=EOcross), [Example 2](https://alpha.twizzle.net/edit/?setup-alg=R2+L+D2+F2+L2+F2+R'+F2+L'+F2+L2+F2+U'+F'+U2+D+B'+L'+U2+D2+R'&alg=F+L'+%2F%2F+Partial+EO%2B2+edges%0AF+%2F%2F+Puts+the+bad+edges+in+FL+and+FD+so+that+you+can+insert+the+other+2+bad+edges+easier.+Also+sets+the+green+edge+on+R.%0AR2'+U+F+%2F%2F+EO%0AR+D'+%2F%2F+finish&stickering=EOcross)
-
- - Opposite 2 bad edges: \
- [Example 1](https://alpha.twizzle.net/edit/?alg=F%27+%2F%2F+2+opposite+bad+edges%2C+doesnt+change+the+EO+itself+but+it+does+affect+the+cross+pieces.%0AD2+R+%2F%2F+3+cross+edges%0AF+U+F+%2F%2F+EO%2Blast+cross+edge%0AD2+%2F%2F+finish&setup-alg=U+L+R%27+D2+F+U+L+F2+D2+R2+D2+B%27+D2+F+R2+U2+F+L2+B2+R&stickering=EOcross), [Example 2](https://alpha.twizzle.net/edit/?setup-alg=L+U%27+F+D%27+L2+D%27+R2+U2+D%27+L2+B2+L2+R%27+B%27+L%27+D%27+L%27+U%27+B2&alg=L2+%2F%2F+blue+cross+edge+%2B+bringing+1+bad+edge+to+F%0AF%27+%2F%2F+solving+the+red+cross+edge+and+setting+up+the+green+one%0AR+U+D%27+F%27+%2F%2F+EO%0AD2+%2F%2F+finish&stickering=EOcross)
-
-- Solving EO differently to influence cross pieces: \
- [Example 1](https://alpha.twizzle.net/edit/?setup-alg=R+U'+L+B2+F2+R+D'+L+F+L2+R2+F+R2+B'+L2+D2+F+R2+B2&alg=B'+R2+B'+%2F%2F+EO%2B3%2C+instead+of+F'+U2+F+which+only+does+EO.+Note+that+the+second+B'+is+also+important+since+it+solved+the+blue+cross+edge+correctly+instead+of+doing+orange%2C+which+ties+into+F%2FB+directions.%0AU'+L2+%2F%2F+finish&stickering=EOcross), [Example 2]()
-
-## Movecount
-
-We've gotten through the theory and things you can do, it's time to implement them in practice. For this, we will use the **Movecount Drill**. It has helped many people and the writer of this article used it singlehandedly drop his movecount from 10.5 to 8.5.
-
-First, set up your CSTimer settings:
-
-1. Go to [CSTimer](https://cstimer.net/).
-2. Click on the gear in the top left corner.
-3. Go to the 'Timer' section.
-4. In the 'entering in times with' box, change the setting from 'timer' to 'typing'.
-
-Now you're ready. The drill itself is very simple:
-
-1. Scramble the cube.
-2. Solve EOCross, and count how many moves it took you. Type that as a time with 2 zeros (so if it took you 15 moves, type 1500).
-3. Solve the rest of the cube.
-
-If you haven't done this drill, repeat it 50 times to get a sense of your average movecount.
-
-Now that you have your average movecount, you want to set your target movecount. It should be set 2 moves above your average movecount. So if your EOCross averaged 10 moves in a session, your target movecount will be set to 12 moves.
-
-After a certain amount of solves in the session (preferably 12, 25 or 50) you want to go over every scramble above the target movecount. You want to repeat the scramble for these and find a solution that is below that target movecount. This will force you to try different approaches to the hardest scrambles and to apply techniques you have learned. For example, you may try to solve a different set of 2 cross pieces while solving EO, and check if they influence the remaining 2 cross edges to a better finish. Then go over the solution once again to find out why. This sort of curiosity and the growth mindset will allow you to make the best and quickest progress.
-
-As you get better, you can also start checking the EOCrosses that were only 1 move longer than the average, and if you get very good (8-9 moves on average), you'll know instinctively to go for the scrambles for which the solutions 'felt' bad, even if they had normal length solutions. But if you're a beginner, don't think about it for now.
-
-If you're really stuck, go to Solvers > EOCross to see what the computer will give you (for x2y, check the first 4 solutions). What 2 first edges does it solve, how does it deal with EO, what approach does it use? You can also use these to find other techniques that you haven't considered.
-
-Eventually, after doing the drill a couple of times, your average movecount will drop. Apply a new target movecount for progression, and repeat the drill.
-
-Continue doing this process until your average movecount drops to 8.5. Then, stop caring about movecount and start practicing for [speed](/improvement-guide/eocross/practicing).
-
-## How to solve EOCross as one step
-
-We want to eventually be able to see EOCross as one step to solve, instead of 2 intermediate ones.
-
-If you recall the start of the article, it talked about being able to merge both steps as you get more skilled. The solution is really just more deliberate practice: after getting comfortable with each approach, you will start to see which ones will have the best balance of how short they are, and how much they influence the rest of the pieces and EO. These will be the best to use for a scramble.
-
-If you want more help on this, you can go to [crystalcube](https://crystalcube.app/) and train the scrambles with the highest n-flips and the longest solutions, and then study the solutions which the computer gives.
diff --git a/pages/he/improvement-guide/eocross/eocross-full-guide.mdx b/pages/he/improvement-guide/eocross/eocross-full-guide.mdx
deleted file mode 100644
index e072363..0000000
--- a/pages/he/improvement-guide/eocross/eocross-full-guide.mdx
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: EOCross Full Guide
-description: The complete guide to improving your EOCross.
-author: yoruba
----
-
-import { Callout, Steps } from "nextra/components";
-
-Here's a step by step guide on how to get your EOCross skills from a beginner to a world class level.
-
-
- Note: the time milestones given here are for x2y neutral, and they will be
- slightly faster for full CN.
-
-
-
-### [Learn EO](/tutorial/eo)
-
-Focus on efficiency and aim for 4-5 move solutions on average.
-
-### Practice EO
-
-Start to plan EO in inspection and become familiar enough that you don't need to put fingers on bad edges (tip: visualize EO like a shape). Get fast at executing it (sub 1 second).
-
-### Learn bad edge placements
-
-If you haven't already, learn how EO gets affected by F and B moves when 1/2/3 bad edges are placed on the F/B face. Learn all of the possible cases for different bad edges placements. This will save you time in inspection as EO will become automatic to trace in harder cases.
-
-### Apply basic EOCross techniques
-
-The most bang for your buck will be to use different direction of F/B moves, and implement 2 edge F/B turns for flexibility. Use the movecount drill to get down to 10 moves on average. For more techniques and drills, check out the [efficiency](/improvement-guide/eocross/efficiency) and [practicing](/improvement-guide/eocross/practicing) articles.
-
-### Improve EOCross efficiency and planning
-
-Practice until you can plan EO+2 every time. Do lots of efficiency practice with previously mentioned techniques and use [crystalcube](https://crystalcube.app/) to get movecount down to 8.5. Improved efficiency will make it easier for you to plan EOCross in [inspection](/improvement-guide/eocross/inspection). Work on that.
-
-### Improve EOCross speed
-
-After that, focus more on the speed and execution of the step. Practice with the drill, this time focusing on speed. For more information, see the speed section of the [Practicing](/improvement-guide/eocross/practicing) article. Along with that, practice planning EOCross faster in inspection.
-
-A good goal to aim for is to plan EOCross within 8 seconds of inspection, being able to execute it in 1.5 seconds, in 9 or less moves on average. This is the skill level equivalent of a 6.5 seconds solver.
-
-### Mastery
-
-Continue practicing. To improve at this step most effectively, master your turning, as your biggest time losses will mainly come from lockups and slight inaccuracies here and there. Eliminate them entirely.
-
-World class EOCross level is executing in 1.2 seconds and below, and being able to plan the step in 4-6 seconds. This at the high level will give you more than enough time for planning the first pair in inspection for every scramble.
-
-
\ No newline at end of file
diff --git a/pages/he/improvement-guide/eocross/inspection.mdx b/pages/he/improvement-guide/eocross/inspection.mdx
deleted file mode 100644
index 9c93511..0000000
--- a/pages/he/improvement-guide/eocross/inspection.mdx
+++ /dev/null
@@ -1,108 +0,0 @@
----
-title: Planning EOCross in Inspection
-description: Approaches to planning an EOCross during inspection time.
-author: yoruba
----
-
-import { Steps } from "nextra/components";
-
-Here you will learn how to consistently plan EOCross in inspection (15 seconds or lower). We recommend first practicing these techniques untimed to avoid forming bad habits.
-
-## Prerequisites
-
-Before learning to plan EOCross, your EO recognition needs to be well-practiced and only take a few seconds. The rules of recognition are no longer rules, but something you can see without conscious effort. In addition, some "training wheel" habits given in the [EO tutorial](/tutorial/eo) should no longer be used:
-
-- Placing fingers on bad edges.
-- Keeping track of only good edges when there are more good than bad.
-
-## Intermediate approach
-
-1. If you're [colour neutral](/improvement-guide/eocross/color-neutrality), pick an option with an easier EO. \
- a. Check the available EO axes. For x2y, there are two axes. \
- b. Check the available cross pieces. For x2y, there are two sets of cross pieces.
-2. Find an efficient **EO+2** solution (EO plus two cross edges).
-3. Track the two remaining cross edges while executing the EO+2.
-
-### How to inspect faster
-
-General focus is important during inspection, especially with EOCross. It can be difficult to maintain at first.
-
-Practice EO recognition with the goal of recognizing all bad edges in 1 second. Then you can save more time by merging steps 1a and 1b: checking EO will be second nature, so just check cross pieces while searching for EO. This can save 3-4 seconds.
-
-### How to select EOCross with CN
-
-As you practice efficiency, you may naturally start identifying better, more efficient EOCross cases. However, it helps to also have a general guide.
-
-#### n-flips
-
-One strategy is to choose based on the **n-flip** (number of bad edges).
-
-Here’s the tier list of possible EO n-flips:
-
-- Best: 0, 2, 4
-- Medium: 6, 8
-- Worst: 10, 12
-
-This is a decent strategy, but it doesn't take into account the cross edges.
-
-#### Easy starts
-
-To account for cross edges, scan for an **easy start:**
-
-- lower n-flips: easy EO+2s.
-- higher n-flips (6 or more bad edges): partial EO+2s
-
-For the majority of scrambles, there's an EO+2 which can be done in 5-7 moves at most on average. In comparison, the average movecount of EO alone is 4-5.
-
-Now, not every scramble will have an easy start. This might be partially an issue of not practicing EOCross enough, but sometimes there genuinely won't be a way to solve EO+2 efficiently. In these situations, still check the EO+2s, even if they have less efficient solutions. For a few of them you might find that after that EO+2, you will only have 0-2 moves left to finish (or just generally a very quick finish). Go with that option if you see it.
-
-However, if the scramble still has no such EO+2s (very rare with x2y, and if you practice your efficiency more), then it's one of the hardest ones, which have the longest solutions. There are 2 ways to handle these:
-
-- Turn very quickly through EO>Cross with only minor influencing.
-- Practice these scrambles beforehand by going on [crystalcube](https://crystalcube.app/), and practice for the 8-9 mover max cases.
-
-You’ll have to look at your EOCross as a whole step, instead of 2 intermediate steps, as well as understand solving EO and cross at the same time, which is a very worthwhile skill that can get your solutions to a new level, so to say.
-
-### Planning the solution:
-
-Step 2 of the Intermediate Approach will be the most time consuming. To get better at it, practice it a lot through the Movecount Drill. Once you get efficiency down, you want to be practicing this for how fast you can spot a good EO+2.
-
-Step 3 is only a step if you only plan EO+2, where you search for the first EO+2 you can find and stick with it, and track the rest afterwards. Once you will be planning full EOCross you will be tracking the last 2 edges on the fly to find the best for your EOCross.
-
-So, if we optimize the process, we will be left with just 2 steps:
-
-## Advanced approach
-
-1. Check your EOs and cross pieces.
-2. Scan for an easy start that influences the other 2 edges the most.
-
-At the highest level, this will take on average 4-6 seconds. This leaves you 6-8 seconds to plan first pair, which is also enough time to be searching for your second pair.
-
-{/* On how to plan first pair and beyond: [insert planning further in inspection article] */}
-
-Detailed plan of action:
-
-
-### Check your EOs and cross pieces
-
-Saw an obvious/easy case? For example:
-
-- best tier EO and the cross pieces close to solving
-- an obvious and easy to execute EO+2
-- a less than 6 move EOCross
-
-Yes: choose that case and plan the solution. \
-No: go to the next step.
-
-### Scan for easy starts that influence cross edges
-
-Look for EO+2s (or partial EO+2s for 6 and higher flips) that influence the last 2 cross edges the most, and are fast to execute.
-
-Saw something to that extent?
-
-Yes: Go with that. \
-No: consider an EO+2 that does not influence the last 2 cross edges well. If it's fast enough to compensate for a worse last 2 edges case, go with it.
-
-As a last resort, do EO then Cross with minor influencing.
-
-
\ No newline at end of file
diff --git a/pages/he/improvement-guide/ll.mdx b/pages/he/improvement-guide/ll.mdx
deleted file mode 100644
index 61c3370..0000000
--- a/pages/he/improvement-guide/ll.mdx
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Last Layer Improvement Guide
-description: An introduction to the LL improvement guide.
-author: crystalcuber
----
-
-This is the complete Last Layer improvement guide written by a high-level ZBLL user.
-Inside you'll find great advice on how to learn and train algs, especially [ZBLL](/improvement-guide/ll/zbll-guide).
-
-To upgrade from 3LLL to 2LLL, [start here!](/improvement-guide/ll/2lll)
diff --git a/pages/he/improvement-guide/ll/2lll.mdx b/pages/he/improvement-guide/ll/2lll.mdx
deleted file mode 100644
index 3101a9f..0000000
--- a/pages/he/improvement-guide/ll/2lll.mdx
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: 2LLL (OCLL+PLL)
-description: Learn OCLL and PLL, a 2-step approach to solving the Last Layer with edges oriented.
-author: yoruba and crystalcuber
----
-
-import AlgSheet from "components/AlgSheet";
-import OCLL from "algs/OCLL";
-import PLL from "algs/PLL";
-
-**OCLL+PLL** is an efficient method of solving the Last Layer (with edges oriented) in just 2 steps.
-In total, there are only 28 algs. It's the most bang of your back way of solving the Last Layer, as it can get you to sub 7 and lower, while maintaining a very low algorithm count. If you haven't learned ZBLL yet, use this method.
-
-CFOP users will already know all of these, even with 2-look OLL.
-
-## Step 1: OCLL
-
-**O**rient the **C**orners of the **L**ast **L**ayer: twist the top corners so the top side is a single color.
-
-This set has 7 algorithms. Recognize the case by the pattern of the top-colored stickers on the corners. Everything else is ignored.
-
-
-
-## Step 2: PLL
-
-**P**ermute the **L**ast **L**ayer: swap the top pieces around to solve the cube.
-
-This set has 21 algorithms. To recognize the case, look for these distinct features of each PLL:
-
-- **Blocks:** rectangular chunks of matching pieces.
-- **Headlights:** pairs of matching corner stickers on the same side.
-- **Adjacent colors:** colors belonging to sides next to each other on a solved cube (e.g. red/green).
-- **Opposite colors:** colors belonging to sides across from each other on a solved cube (e.g. red/orange).
-
-
diff --git a/pages/he/improvement-guide/ll/_meta.tsx b/pages/he/improvement-guide/ll/_meta.tsx
deleted file mode 100644
index 08e0f50..0000000
--- a/pages/he/improvement-guide/ll/_meta.tsx
+++ /dev/null
@@ -1,7 +0,0 @@
-export default {
- "2lll": "OCLL and PLL",
- "zbll-guide": "ZBLL Guide",
- "zbll-algs": "ZBLL Algs",
- "zbll-recog": "ZBLL Recog",
- "zbll-practice": "Practicing ZBLL"
-}
diff --git a/pages/he/improvement-guide/ll/zbll-algs.mdx b/pages/he/improvement-guide/ll/zbll-algs.mdx
deleted file mode 100644
index 1d881b0..0000000
--- a/pages/he/improvement-guide/ll/zbll-algs.mdx
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: ZBLL Alg Sheets
-description: Find the best algs to learn
-author: yoruba
----
-
-These are our recommended ZBLL alg sheets:
-
-[**Daniel V. Egdal:**](https://speedcubedb.com/algsheet/3564/ZBLLAS) best sheet, all of the algs have been tested to sub 1 (measured by single time).
-
-[**Juju:**](https://docs.google.com/spreadsheets/d/1-uwmZHf4vwJxFgeB3-TiF8MQ0RFSS30d5CUK96PoIwk/edit#gid=0) most popular sheet, provides a variety of solid algs and training resources.
-
-[**Yoruba:**](https://docs.google.com/spreadsheets/d/1AVFcEcnPNlmBl3T3Q7YeoreHBc-XU4ad9vR8lGzXsp0/edit?usp=drivesdk) author's sheet, with all of the algs done sub 1-1.2 (measured with mo3/ao5). Also has AUF stickers.
diff --git a/pages/he/improvement-guide/ll/zbll-practice.mdx b/pages/he/improvement-guide/ll/zbll-practice.mdx
deleted file mode 100644
index e65932a..0000000
--- a/pages/he/improvement-guide/ll/zbll-practice.mdx
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: How to Practice ZBLL
-description: A step-by-step guide to practicing and maintaining ZBLL algs.
-author: yoruba
----
-
-For ZBLL practice, there are essentially 4 things you need to address:
-
-1. Case recognition speed.
-2. Speed of your algorithms, as well as getting the algorithms in your muscle memory.
-3. 'Case-Alg' connection: You don't just need to learn the algorithm, you also have to associate it with the case it's going to solve.
-4. AUF stickers.
-
-You can figure out why all of these factors are important: when you do ZBLL in a solve, it is boiled down to 3 steps:
-
-- recognition (which covers point 1).
-- execution of the algorithm (which cover points 2 and 3).
-- post AUF (which covers point 4).
-
-## How to practice, step by step
-
-1. You get your algs from your sheet and practice them one by one with good turning, and try to mindfully associate each alg with their corresponding case. You can do that by doing the inverse of your alg and just seeing what case does the alg solve. While doing that, assign an AUF sticker to your algs (if you use my sheet, it's already done for you).
-2. Then get your timer and drill your cases to at least sub 1.2 seconds. This may be too hard for your speed, so you can aim for 1.5 instead, but keep in mind that you want your algs at 1-1.2 at the highest level.
-3. Now go into the [ZBLL trainer](https://bestsiteever.ru/zbll/#/select) and practice your algs. On the right side, choose the cases that you're going to practice, and hit ‘recap each case once’ on the left.
-4. Do 3 'recaps' where you simply focus on good recognition, turning and looking at the AUF sticker.
-5. After that, do recaps where you aim for recog+execution speed, until you reach a certain speed goal.
-
-You can set 2 kinds of these goals: Either a set time, so sub 3, or for advanced solvers, sub 2 to low 2, or simply aim for a time that is below 3rd of your average solve time, since LL takes about this much in solves.
-
-Tip: You don't need to practice all of the 12 algs at once. You can learn them in halves (so 6 each) or even in thirds (4 each), that way you can practice each case more.
-
-You can use this learning process for the first 2-4 days or so. The rest of the week will be spent on daily practice of these 12 algs. During that time, continue using the ZBLL trainer to solidify these cases further into your muscle memory, and start incorporating the learned algorithms into your solves.
diff --git a/pages/he/improvement-guide/ll/zbll-recog.mdx b/pages/he/improvement-guide/ll/zbll-recog.mdx
deleted file mode 100644
index 3bd3f4e..0000000
--- a/pages/he/improvement-guide/ll/zbll-recog.mdx
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: ZBLL Recognition
-description: Learn how to recognize any ZBLL case.
-author: yoruba
----
-
-import YouTubeEmbed from "components/YouTubeEmbed";
-
-When you first start learning ZBLL, it might seem like some cases are too similar to differentiate between each other. Is it even possible to recognise the cases quickly enough in a solve?
-
-Yes! All you need is a consistent recognition system.
-
-## Systems
-
-Through many years, various ways of recognizing ZBLL have been invented to simplify the recognition as much as possible. For an overview of them, you can check [this document.](https://docs.google.com/spreadsheets/d/1nrrO2xaIHcI8EKaJUxj0PDzx4CJ58jqhsFDZSbxQaoQ/edit#gid=1949489381)
-
-## Which one to choose?
-
-It is highly recommended to learn the **Baum-Harris (BH)** system for recognition. It's the best choice for beginners due to the consistency of the system: Where for blocks you would have to look for patterns that are individual to every case, here you just need to learn 12 set patterns that are guaranteed to appear. The straightforward nature of the system is also its strong suit: After COLL, you just need to recognize a set BH pattern, instead of an arbitrary block or pattern that can appear at different sides of the cube for different cases, which might require multiple AUFs, especially if you're in the learning stage.
-
-## How to learn Baum Harris?
-
-We have a video about this on our channel:
-
-
diff --git a/pages/he/improvement-guide/zzf2l/_meta.tsx b/pages/he/improvement-guide/zzf2l/_meta.tsx
deleted file mode 100644
index 1391090..0000000
--- a/pages/he/improvement-guide/zzf2l/_meta.tsx
+++ /dev/null
@@ -1,8 +0,0 @@
-export default {
- "zzf2l-full-guide": "ZZF2L Full Guide",
- "pair-solutions": "Pair Solutions",
- "lookahead": "Lookahead Progression",
- "pair-choice": "Pair Choice",
- "deduction": "Deduction",
- "multislotting": "Multislotting"
-}
diff --git a/pages/he/improvement-guide/zzf2l/lookahead.mdx b/pages/he/improvement-guide/zzf2l/lookahead.mdx
deleted file mode 100644
index d0aa82b..0000000
--- a/pages/he/improvement-guide/zzf2l/lookahead.mdx
+++ /dev/null
@@ -1,133 +0,0 @@
----
-title: ZZF2L Lookahead Progression
-description: How to develop lookahead during ZZF2L.
-author: yoruba
----
-
-import TwistyPlayer from "components/TwistyPlayer";
-
-**Lookahead** is the skill of focusing on the next step of your solve while doing the current one.
-
-Lookahead is not just limited to F2L: just like you can focus on your third pair while solving your second, you can also focus on your first pair while solving EOCross, or focusing on your Last Layer while solving your Last Pair. This article will focus only on F2L though.
-
-Prerequisite: Improve your F2L solutions first, and get them in your muscle memory.
-
-This will be similar to Feliks's lookahead tutorial on cubeskills, but in a context of ZZF2L. Great resource, can also be applied to other methods like Roux if you switch the terms a bit. Check it out [here](https://www.cubeskills.com/blog/lookahead-progression-framework).
-
-Lookahead in ZZF2L has 3 stages to progress:
-
-**1. No lookahead:** where you spot the pieces of your f2l pair, solve it, and then spot the pieces of the next pair. Here you aren't doing any lookahead.
-
-**2. Tracking:** While you solve your F2L pair, you look for the pieces of another pair. As you spot them, you track the pieces of this other pair, so that after you solve the first pair you immediately know where the pieces of your next pair are.
-
-**3. Knowing:** While you solve your F2L pair, you spot the pieces of another pair and you know where they are going to end up after solving the first pair. This allows you to maximize your TPS without lookahead disadvantages.
-
-## How to start tracking
-
-First off, you need to take a bit of time to build a habit of not looking at what you're solving and tracking other pieces. We can do it by doing a drill.
-
-### Setting up CSTimer
-
-1. Go to [CSTimer](https://cstimer.net/).
-
-2. Set the left bar on the top to '3x3x3', and then the right bar to 'Custom'. Then click on the gear next to the 'Custom' bar, and set the following Scramble Options: clear the 'OriE' section, and disable the 'PermE-DL', 'PermE-DF', 'PermE-DR' and 'PermE-DB' options. This will generate scrambles with EOCross already solved.
-
-### The first drill
-
-1. Scramble the cube, you should have EOCross already solved.
-2. Spot the pieces of an F2L pair. We'll call this pair, which we are currently solving as 'pair A'
-3. Before you solve 'pair A' look for the pieces of another pair. Well call this pair, the one we are currently tracking as 'pair B'
-4. While solving pair A follow (or track) the pieces of pair B. See the pieces going around the cube and focus on them.
-5. Repeat steps 3-4 until you solve F2L. You don't need to do step 2 since you've already tracked the F2L pieces beforehand.
-
-If tracking both pieces of pair B is too difficult, start with a corner first. Once that becomes comfortable, add an edge.
-
-This drill is good for building a habit of looking at other pieces, but it doesn't really represent the 'flow' we want to achieve in F2L: top ZZ solvers don't just pause before each pair to spot other pieces, we want to eventually solve the whole F2L mostly pauseless, which is the main purpose and benefit of lookahead.
-
-That's why after you've made looking for other pieces second nature using the previous drill, we want to stop doing it (you can still do it as a warm up, but there won't be a point in spamming it anymore). Instead, we will incorporate a drill similar to the previous one, but with some adjustments that makes it more realistic for real speedsolves.
-
-### The second drill
-
-1. Scramble the cube as before (EOCross solved).
-2. Spot the pieces of an F2L pair (pair A).
-3. Solve pair A. While solving this pair, look around for the pieces of another F2L pair (pair B).
-4. Repeat step 3 until all pairs are solved.
-
-You could have noticed that this drill is exactly like the previous one, just with steps 3 and 4 merged into a single step. So instead of spotting your pieces of Pair B beforehand, you need to spot them on the fly as you solve Pair A. Here's how to do that, step by step:
-
-1. Slow down your turning a bit and focus
-2. Force yourself to not concentrate at the pair you're currently solving. The easiest way to do that is to solve the pair with muscle memory.
-3. Instead look around the cube to find the pieces for your next pair. Look after the U layer and unsolved slots.
-
-You want to do this drill at 2 speeds: The first should be slow enough so that you can do the drill comfortably without pauses or problems (do this as warmup), and then for training, use a speed that is challenging, but possible to do. This speed will gradually increase as you train more and become better. However, you need to be wary of the 2 main problems that you're going to likely face:
-
-### Problem #1: Tunnel vision
-
-**F2L tunnel vision** is the bad habit of always settling for the first 2 F2L pieces that you see, no matter how bad of a case they produce. Poor pair choice can lead to more inefficient solutions.
-
-For example, if the first thing we see is the green-orange pair, it results in a very long 12-mover. It's also a front pair, so if we solve it first that hinders lookahead (compared to solving a back pair first, like blue-orange).
-
-
-Moves: `(U R U' R' U' R U' R' U R U' R') (R' U' R U' R' U' R)`
-
-However, if we solve the blue-orange pair first, we have a much nicer 5-mover and we fill a back slot to help our lookahead.
-
-
-Moves: `(R U' R2' U' R) (R U R' U2' R U R')`
-
-Tunnel vision is common even at a higher level of cubing (sub 8-10), and it's also holding back a lot of people. For some, it's a bad habit that they have built up for years. You want to address this now.
-
-It's a major downside of the above drills, if not addressed.
-
-**Solution:** Improve [Pair Choice](/improvement-guide/zzf2l/pair-choice) + Be more aware of your other pairs
-
-### Problem #2: Can't see pieces
-
-You may be solving an F2L pair and trying to spot the pieces for your next one, but you can't spot anything. Annoying, but it's easier to address than the first problem.
-
-Solution: [Deduction](/improvement-guide/zzf2l/deduction) + pair choice (prioritizing back slots)
-
-Address these 2 problems and continue training your lookahead with the drill until you can lookahead comfortably with your normal turning speed.
-
-## From Tracking to Knowing
-
-You might start to realize that for most cases, you won't actually need to track your pieces to the very end to know what case you're going to get. For the first moves, sure, but in the last 3 moves you might not need to track anymore since you can visualise the rest in your mind. This signals that you're currently at a skill level between Tracking and Knowing.
-
-What you should know at this stage is that you should still continue looking ahead, even if you know where your next pair is. In that case, focus on the next pair after that next pair.
-
-### How to start Knowing
-
-Knowing can be developed naturally from doing the lookahead drills and general F2L practice. From repeating F2L solutions, you will start to notice how simple triggers like R U' R', R U2 R' affect the rest of the cube. Then, considering that most of your F2L pair solutions before Last Slot are just a combination of those triggers, you will be able to predict your case most of the time.
-
-So, you would want to continue doing the training drill in the 'Tracking' section, but just be more mindful that eventually, you would want to know where the pieces end up instead of tracking them.
-
-To accelerate the process, you can go over each case manually and learn how each case affects the pieces on the cube. Apply the inverse of an F2L case on a fully solved cube to see how the pieces move around.
-
-
-Moves: `R U2 R' U' R U R'`
-
-In this insert, we can see that FR and DFR are kept together. Same with UL and UBL. You may also notice that the UFL corner gets both twisted counterclockwise and moved by U2, and so on. Having an idea of how this insert moves pieces around is essential to knowing where pieces will end up.
-
-You would start with the 3 movers, and then the 6-7 movers that have at least 1 piece in the U layer (you would want to learn by breaking the pairs into triggers, instead of individual moves). Then go on to make untimed F2L solves to practice recalling what pieces are going to move to what spots.
-
-We can also use a modification of our very first drill mentioned in here, you spot Pair A and the pieces for Pair B, but then you close your eyes and solve these 2 pairs blindfolded as fast as possible. This will let you put the before mentioned process of seeing how pieces move around in practice.
diff --git a/pages/he/improvement-guide/zzf2l/pair-choice.mdx b/pages/he/improvement-guide/zzf2l/pair-choice.mdx
deleted file mode 100644
index f560a27..0000000
--- a/pages/he/improvement-guide/zzf2l/pair-choice.mdx
+++ /dev/null
@@ -1,53 +0,0 @@
----
-title: ZZF2L Pair Choice
-description: Pick the right F2L pair to solve for better efficiency.
-author: yoruba
----
-
-import TwistyPlayer from "components/TwistyPlayer";
-
-**Pair choice** is the skill of seeing multiple pairs to solve and choosing the best one. 'Best' might not always mean choosing the fastest pair to solve immediately, as it may influence the other pairs to be worse. This is a very important aspect of F2L.
-
-In this example, there is a 3-move pair and a 4-move pair. If we chose the 3-mover first, the 4-move pair becomes much worse:
-
-
-Moves: `(R U' R') U' (R' U' R U' R' U R)`
-
-But if we choose the 4-mover first, the 3-mover is preserved. This is 4 moves shorter!
-
-
-Moves: `(U' R' U' R) U (R U' R)'`
-
-It's the transition of looking at F2L not as 4 individual pairs (intermediate approach), but as one step (advanced approach) that will save you the most time.
-
-## Prerequisites
-
-In order to consider pair choice, there are some prerequisites:
-
-- Optimize pair solutions beforehand. If you don't do that, chances are that most of the time all of your choices would be equally as bad.
-- Look at a pair, and immediately know the solution, as well as the quality of that solution. You can categorize them into 3 cases: free pairs/3 movers, 6-7 movers (pieces in U), and the rest.
-- Deduction (learn more [here](/improvement-guide/zzf2l/deduction))
-
-Developed through focused untimed f2l only solves, practice by trying out different things, looking for patterns and make sure you're aware of all of your F2L pairs.
-
-## Rules of thumb
-
-1. Prioritize free pairs and easiest pairs.
-2. Look out for the U layer: if an f2l case has an F2L piece in U, it's most likely good.
-3. Pair order: solve back/right/left slots first.
-
-### Pair order
-
-It's preferable for your first F2L pairs to be BL+BR (back slots), BL+FL (left slots), or BR+FR (right slots). This will ensure that you will have all of your pieces visible, as well as it will make sure that your last two pairs will be fastest on average. That means you should be avoiding solving both front first, or slots that are diagonal (FL+BR, FR+BL) which interfere with lookahead and turning.
diff --git a/pages/he/tutorial.mdx b/pages/he/tutorial.mdx
deleted file mode 100644
index 147b8b1..0000000
--- a/pages/he/tutorial.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: ZZ Tutorial
-description: The complete beginners' guide to the Modern ZZ method.
-author: crystalcuber
----
-
-Welcome to the Modern ZZ Tutorial for solving the Rubik's Cube.
-It features visual, beginner-friendly guides for each step of the method.
-
-The [EO tutorial](/tutorial/eo) introduces the principle of Edge Orientation, a core concept in ZZ.
-It's also very useful for Fewest Moves Challenge (FMC), the CFOP method and Rubik's Cube theory.
-
-Then check out the tutorials for each step:
-
-1. [EOCross](/tutorial/eocross)
-2. [ZZ First 2 Layers (ZZF2L)](/tutorial/zzf2l)
-3. [Last Layer (LL)](/tutorial/ll)
-
-## Prerequisites
-
-Before using this tutorial, you need to know how to:
-
-- Solve the cube.
-- Read standard move notation.
diff --git a/pages/he/tutorial/_meta.tsx b/pages/he/tutorial/_meta.tsx
deleted file mode 100644
index f769e46..0000000
--- a/pages/he/tutorial/_meta.tsx
+++ /dev/null
@@ -1,6 +0,0 @@
-export default {
- "eo": "Edge Orientation (EO)",
- "eocross": "Step 1: EOCross",
- "zzf2l": "Step 2: ZZ First 2 Layers (ZZF2L)",
- "ll": "Step 3: Last Layer (LL)"
-}
diff --git a/pages/he/tutorial/eocross.mdx b/pages/he/tutorial/eocross.mdx
deleted file mode 100644
index da30e49..0000000
--- a/pages/he/tutorial/eocross.mdx
+++ /dev/null
@@ -1,231 +0,0 @@
----
-title: How to solve EOCross
-description: Learn EOCross, the first step of the ZZ Method.
-author: S1neWav_ and crystalcuber
----
-
-import TwistyPlayer from "components/TwistyPlayer";
-import { ReconViewer } from "components/ReconViewer";
-import { Callout } from "nextra/components";
-
-## Introduction
-
-EOCross is the first step of the modern ZZ method.
-We solve two properties:
-
-- [Edge Orientation](/tutorial/eo).
-- The **cross:** the 4 edges that belong at the bottom.
-
-A solved EOCross looks like this:
-
-
-
-The turquoise stickers are there to show the orientation of the unsolved edges.
-Good edges have turquoise on the ["purple orbit"](/tutorial/eo#orbits).
-We can see that they're all good.
-
-
- Frequently asked questions
-
-**What's the purpose of EOCross?**
-
-EOCross slows down the beginning of the solve compared to just solving CFOP cross.
-However, EOCross sets up a rotationless, ergonomic F2L step. With EO solved, there
-is a simpler way to [deduce](/improvement-guide/zzf2l/deduction) F2L edges. Last
-Layer also becomes simpler. OLL and PLL is easier to learn for ZZ (28 algs instead
-of 78), or you can learn full ZBLL and use it every solve.
-
-**Should I learn EOLine first?**
-
-We don't recommend EOLine as a stepping stone to EOCross for two reasons:
-
-1. EOLine F2L is fundamentally different from EOCross F2L, doesn't make sense to learn both types.
-2. EOCross is hard at first, but using it from the start will help build inspection skills.
-
-
-
-In this tutorial, we'll solve EO first and then cross separately. For speed, you can later learn how to solve this as one step in the [Improvement Guide](/improvement-guide/eocross).
-
-## Step 1: EO
-
-The first step is to solve edge orientation. This process is explained in our [EO tutorial](/tutorial/eo).
-
-## Step 2: Cross
-
-Once EO is done, solve the four cross edges.
-All you need are the "natural" R, U, L, and D moves, and you can also use `F2` and `B2`.
-
-If you know CFOP or Beginner's method, you are already familiar with solving a cross.
-Just make sure you avoid moves that disrupt EO such as cube rotations, quarter-turn F/B-layer moves and slice moves.
-
-If you don't have experience with cross, expand the below section to learn more.
-
-
-How to solve cross
-
-Our goal is to solve the **cross edges:** the four edges that belong to the bottom layer of the cube.
-Cross edges always have the color of the bottom face, so that's how you find them.
-
-We need to move all cross edges to the bottom, because that's where they belong solved.
-To move an edge to the bottom, use R/L moves, `F2` or `B2` (whichever one that moves the edge).
-
-Sometimes, there will be a bottom cross piece that will get "kicked out" when you move another edge to the bottom.
-This can be avoided by doing a D-layer turn to move the bottom cross piece out of the way.
-To move this blue-white edge to the bottom, we can first do `D'` to move the red-white edge out of the way.
-Then we can do `R'`.
-
-
-
-Now we know how to move any cross edge to the bottom.
-We could put all cross edges on the bottom, and it would look like this.
-
-
-
-However, this is not a solved cross!
-Our goal is to solve the cross pieces, which looks something like this:
-
-
-
-You can see that the colours match between the edges and the front/left/right/back centers.
-
-In order to match the edges with the centers, let's first take a look at how centers are positioned.
-
-Centers never move around the cube.
-So there are relationships between their colors that never change.
-For example, the blue and green centers are always opposite each other, and the blue center is always next to the orange center.
-
-We need our cross edges to have the same color relationships as the centers.
-That way, at the end of our cross solution they will line up with the centers.
-It would be too restrictive for our solution to keep the solved edges matching the centers at all times.
-
-Here's an example where we use these relationships to solve cross:
-
-
-
-There are already two cross edges at the bottom, but they don't have the right relationship.
-With white as our bottom color, the red center is to the left of the green center.
-However, the cross edge with red is to the _right_ of the cross edge with green.
-
-We can fix that by replacing the green-white cross edge with the blue-white cross edge.
-
-
-Move: `R`
-
-Now the two edges at the bottom have the right relationship.
-The blue center is to the left of the red center, and the blue edge is to the left of the red edge.
-
-We can continue moving edges down while maintaining the right color relationships.
-We can do `D2 R'` to place the blue cross edge opposite to the green cross edge, just like how the blue and green centers are opposite.
-
-
-
-Now there's only one remaining cross edge, on the left side.
-We can finish with `D L'`.
-
-
-
-
-
-### Example EOCross
-
-
-
-
-
-### Troubleshooting
-
-If you find that edges are unsolvable or end up twisted in their spot, it means EO is not complete yet.
-Make sure that all edges are good before solving cross.
-
-### Influencing
-
-Once you are comfortable with EOCross, you can improve your solutions with a technique called **influencing**.
-This means changing your EO solution to make the resulting cross better.
-Start paying attention to the direction of F and B turns during EO (deciding between F and F' for example).
-
-Here are some examples of basic influencing:
-
-- [Example 1: some influencing](https://alpha.twizzle.net/edit/?setup-alg=F%27+R2+F2+L%27+F2+L%27+U2+R+F2+U2+R+U+B+L2+D2+F+R%27+B%27+F2&alg=%2F%2F+EO+%28with+some+influencing%29%0AD%27+B+U+R%27+%2F%2F+D%E2%80%99+B+puts+3+edges+on+B+face+then+orients+them%2C+U+R%E2%80%99+puts+the+last+4+bad+edges+on+F+face%0AF+%2F%2F+we+do+F+instead+of+F%E2%80%99+because+it+places+blue+and+green+edges+relative+to+each+other+and+places+green+and+orange+edges+relative+to+each+other%0A%2F%2F+Cross%0AR%27+L2+D+L2&stickering=EOcross)
-- [Example 2: more influencing](https://alpha.twizzle.net/edit/?setup-alg=F2+L2+D+B2+U+F2+U+R2+U%27+R2+F%27+U+L2+F+R%27+B+D+F+R+D2&stickering=EOcross&alg=%2F%2F+EO+%28with+more+influencing%29%0AB+%2F%2F+since+3+bad+edges+are+already+on+the+B+face%2C+we+start+EO+by+orienting+3+edges+on+the+B+face.+we+do+B+instead+of+B%E2%80%99+because+it+places+blue+and+red+edges+relative+to+each+other+nicely%0AL%27+U+R%27+U%27+%2F%2F+places+the+last+4+bad+edges+on+F%0AF%27+%2F%2F+we+do+F%E2%80%99+instead+of+F+because+it+places+orange+relative+to+the+red+and+blue+edges+we+placed+correctly+earlier%0A%2F%2F+Cross%0AR%27+D%27+L%27+D%27)
-
-There are many forms of influencing, [click here](/improvement-guide/eocross/efficiency#influencing) for more details.
-
-## What's next?
-
-We suggest doing some untimed EOCross solves to become more familiar.
-The next step is [ZZ First 2 Layers](/tutorial/zzf2l).
diff --git a/pages/he/tutorial/ll.mdx b/pages/he/tutorial/ll.mdx
deleted file mode 100644
index 76b93fb..0000000
--- a/pages/he/tutorial/ll.mdx
+++ /dev/null
@@ -1,129 +0,0 @@
----
-title: How to solve the Last Layer
-description: Learn how to solve the Last Layer in the ZZ Method.
-author: S1neWav_ and crystalcuber
----
-
-import TwistyPlayer from "components/TwistyPlayer";
-import AlgSheet from "components/AlgSheet";
-import OCLL from "algs/OCLL";
-import CP from "algs/CP";
-import EPLL from "algs/EPLL";
-import styles from "./ll.module.css";
-
-## Introduction
-
-Last Layer (LL) is the final step of the ZZ Method.
-After solving the First 2 Layers, we use algorithms (memorized move sequences) to solve the top layer.
-
-CFOP users will already know to solve the Last Layer.
-The only difference with ZZ is that the edges are oriented, which reduces the total number of cases.
-For CFOP users, this means only the 7 cross-on-top OLL cases will occur.
-
-The rest of this tutorial doesn't require knowledge of CFOP.
-
-The ultimate goal of Last Layer in ZZ is to solve it in one step (ZBLL), but this requires learning 493 algorithms.
-To make it easier, we'll split it into 3 steps, or **looks**. In total, there are 13 algorithms.
-
-This approach is called **3-Look Last Layer** (3LLL).
-Here are the steps:
-
-1. **OCLL:** **O**rient the **C**orners of the **L**ast **L**ayer. \
- This step twists the top corners so the top side is a single color.
-2. **CP:** **C**orner **P**ermutation \
- This step swaps the corners around so they're solved relative to each other.
-3. **EPLL:** **E**dge **P**ermutation of the **L**ast **L**ayer. \
- This step swaps the edges around so the top layer is completely solved.
-
-## Step 1: OCLL
-
-There are 7 OCLL cases.
-We recognize them by the shape formed by the top-colored stickers on the top layer.
-Everything else is ignored.
-
-We call a corner "oriented" if its top-colored sticker is on the top.
-
-An important pattern for OCLL recognition is called **headlights:** a pair of matching corner stickers on the same side.
-
-
-
-
-
-Starting with the cases with no oriented corners:
-
-- H has two pairs of headlights.
-- Pi (π) has only one pair of headlights.
-
-Next, the cases which have exactly one oriented corner:
-
-- Sune has three misoriented corners that each need to twist clockwise.
-- For antisune, they need to twist counterclockwise.
-
-Finally, the cases with exactly two corners oriented:
-
-- U has a pair of headlights.
-- T has no headlights, but the two oriented corners are adjacent to each other.
-- L has no headlights, and the two oriented corners are opposite each other.
-
-## Step 2: CP
-
-There are only two CP cases.
-Like in OCLL, we look for headlights, but they look a bit different:
-
-
-
-
-
-To recognize which case you have, look at the colors on the sides of the corners and ignore everything else.
-If you see only one pair of headlights, then it's an adjacent swap.
-If there are no headlights, then it's a diagonal swap.
-
-## Step 3: EPLL
-
-There are 4 EPLL cases. Here they are:
-
-
-
-First, learn these color relationships:
-
-- **Adjacent colors:** colors belonging to sides next to each other on a solved cube (e.g. red/green).
-- **Opposite colors:** colors belonging to sides across from each other on a solved cube (e.g. red/orange)
-
-For EPLL, we recognize the case by looking at the color relationships on the sides of the cube.
-
-- H has opposite colors on all four sides.
-- Ua and Ub have one solved edge. With that solved edge in the back:
- - Ua has opposite colors on the right side.
- - Ub has opposite colors on the left side.
-- Z has adjacent colors on all four sides.
-
-## Stepping up to 2LLL
-
-After learning 3LLL and getting comfortable with it, we can unlock more speed.
-We can combine CP and EPLL into one step called **PLL** (**P**ermutation of the **L**ast **L**ayer).
-There are 21 PLL algs, but the nice part is that you'll already know 6 PLLs from CP and EPLL.
-Now you will have a 2-look last layer (**2LLL**) every solve.
-
-Check out 2LLL [here](/improvement-guide/ll/2lll).
-
-## What about 1LLL?
-
-You can even solve the entire Last Layer in a single step, which is a significant speed advantage.
-In ZZ, you need to learn 493 algorithms in total (compared to 3916 for CFOP).
-Learn more [here](/improvement-guide/ll/zbll-guide).
diff --git a/pages/he/tutorial/ll.module.css b/pages/he/tutorial/ll.module.css
deleted file mode 100644
index d43f412..0000000
--- a/pages/he/tutorial/ll.module.css
+++ /dev/null
@@ -1,4 +0,0 @@
-.headlights {
- width: 200px;
- height: 200px;
-}
diff --git a/pages/zh/blog/story.mdx b/pages/zh/blog/story.mdx
index 5b9431b..130c43d 100644
--- a/pages/zh/blog/story.mdx
+++ b/pages/zh/blog/story.mdx
@@ -45,8 +45,7 @@ We needed to create interactive 3D cubes that would show how EO worked.
Thankfully, [`cubing.js`](https://js.cubing.net/cubing/) is an amazing tool that helped us build these visualizations.
diff --git a/pages/zh/improvement-guide/zzf2l/lookahead.mdx b/pages/zh/improvement-guide/zzf2l/lookahead.mdx
index d0aa82b..620fd13 100644
--- a/pages/zh/improvement-guide/zzf2l/lookahead.mdx
+++ b/pages/zh/improvement-guide/zzf2l/lookahead.mdx
@@ -71,8 +71,7 @@ For example, if the first thing we see is the green-orange pair, it results in a
experimentalSetupAlg="z2"
alg="(U R U' R' U' R U' R' U R U' R') (R' U' R U' R' U' R)"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-ID,CORNERS:IID-IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-ID,CORNERS:IID-IIII,CENTERS:DDDDDD"
tempoScale="3"
/>
Moves: `(U R U' R' U' R U' R' U R U' R') (R' U' R U' R' U' R)`
@@ -83,8 +82,7 @@ However, if we solve the blue-orange pair first, we have a much nicer 5-mover an
experimentalSetupAlg="z2"
alg="(R U' R2' U' R) (R U R' U2' R U R')"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-I-,CORNERS:II--IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIII-I-,CORNERS:II--IIII,CENTERS:DDDDDD"
tempoScale="3"
/>
Moves: `(R U' R2' U' R) (R U R' U2' R U R')`
@@ -121,8 +119,7 @@ To accelerate the process, you can go over each case manually and learn how each
experimentalSetupAlg="z2"
alg="R U2 R' U' R U R'"
experimentalSetupAnchor="end"
- background="none"
- tempoScale="2"
+ tempoScale="2"
/>
Moves: `R U2 R' U' R U R'`
diff --git a/pages/zh/improvement-guide/zzf2l/multislotting.mdx b/pages/zh/improvement-guide/zzf2l/multislotting.mdx
index dab3943..ad2bec1 100644
--- a/pages/zh/improvement-guide/zzf2l/multislotting.mdx
+++ b/pages/zh/improvement-guide/zzf2l/multislotting.mdx
@@ -19,8 +19,7 @@ Why do that? It will give you a general understanding of when to apply multislot
@@ -34,8 +33,7 @@ Why do that? It will give you a general understanding of when to apply multislot
@@ -52,8 +50,7 @@ doesn't.
Good solution (shown above): insert FL with `U`:
@@ -73,8 +70,7 @@ Here's an example: DFR and FL are solved. If open slots are available, you could
experimentalSetupAlg="z2"
alg="D R U2 R' D' D2 R' U' R D2"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:-DIDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:-DIDIIII,CENTERS:DDDDDD"
tempoScale="1.5"
/>
@@ -87,8 +83,7 @@ With pseudoslotting, you can do that all at once. Here, we can do a D move to al
experimentalSetupAlg="z2"
alg="D R U R' U2 R U' R' D'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
tempoScale="1.5"
/>
Moves: `D (R U R' U2 R U' R') D'`
@@ -106,8 +101,7 @@ In this example, the regular F2L pairs are both 7-movers, not great. But an edge
experimentalSetupAlg="z2"
alg="R U' R' D R U' R' D'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DD,CORNERS:-DDDIIII,CENTERS:DDDDDD"
tempoScale="1.5"
/>
Moves: `(R U' R') (D R U' R' D')`
diff --git a/pages/zh/improvement-guide/zzf2l/pair-choice.mdx b/pages/zh/improvement-guide/zzf2l/pair-choice.mdx
index f560a27..0d07373 100644
--- a/pages/zh/improvement-guide/zzf2l/pair-choice.mdx
+++ b/pages/zh/improvement-guide/zzf2l/pair-choice.mdx
@@ -14,8 +14,7 @@ In this example, there is a 3-move pair and a 4-move pair. If we chose the 3-mov
experimentalSetupAlg="z2"
alg="R U' R' U' R' U' R U' R' U R"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
/>
Moves: `(R U' R') U' (R' U' R U' R' U R)`
@@ -25,8 +24,7 @@ But if we choose the 4-mover first, the 3-mover is preserved. This is 4 moves sh
experimentalSetupAlg="z2"
alg="U' R' U' R U R U' R'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-D-,CORNERS:DD--IIII,CENTERS:DDDDDD"
/>
Moves: `(U' R' U' R) U (R U' R)'`
diff --git a/pages/zh/improvement-guide/zzf2l/pair-solutions.mdx b/pages/zh/improvement-guide/zzf2l/pair-solutions.mdx
index be06cd8..904faba 100644
--- a/pages/zh/improvement-guide/zzf2l/pair-solutions.mdx
+++ b/pages/zh/improvement-guide/zzf2l/pair-solutions.mdx
@@ -58,8 +58,7 @@ When optimizing efficiency more, take note of the alternative solutions that pri
experimentalSetupAlg="z2"
alg="R U2' R2' U' R2 U' R'"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDDD-,CORNERS:DD-DIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDDD-,CORNERS:DD-DIIII,CENTERS:DDDDDD"
/>
But with the FR slot open, there's no need for that. This mean the case could now be solved with just `R U2 R2 U' R`:
@@ -68,8 +67,7 @@ But with the FR slot open, there's no need for that. This mean the case could no
experimentalSetupAlg="z2"
alg="R U2' R2' U' R"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDID-,CORNERS:DD-IIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIIDID-,CORNERS:DD-IIIII,CENTERS:DDDDDD"
/>
One example of these free slot solutions is **keyhole:** when you have a slot with only one solved piece, you can leverage an open slot to insert the other piece.
@@ -88,8 +86,7 @@ In Step 3, insert the edge into the slot that it belongs to. Here's an example:
experimentalSetupAlg="z2"
alg="D' R U' R' D"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:DDIDIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIID-DI,CORNERS:DDIDIIII,CENTERS:DDDDDD"
/>
Moves: `D' R U' R' D`
@@ -105,8 +102,7 @@ When inserting a corner, the D move in Step 2 should be to move the spot the cor
experimentalSetupAlg="z2"
alg="D' L' U L D"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIIIIDDD,CORNERS:IDD-IIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIIIIDDD,CORNERS:IDD-IIII,CENTERS:DDDDDD"
/>
Moves: `D' L' U L D`
@@ -120,8 +116,7 @@ After going through LS, you could then check the cases where one of the pieces i
experimentalSetupAlg="z2"
alg="R' F2 R F2"
experimentalSetupAnchor="end"
- background="none"
- experimentalStickeringMaskOrbits="EDGES:DDDDIIII-IDD,CORNERS:-DDIIIII,CENTERS:DDDDDD"
+ experimentalStickeringMaskOrbits="EDGES:DDDDIIII-IDD,CORNERS:-DDIIIII,CENTERS:DDDDDD"
/>
So the only cases left are the ones with both pieces in the F2L slots, what about those? Bar a few good cases, it's not recommended to learn them. Why? Because when these cases appear in a solve, there's a very high chance that there will be another F2L pair on the cube that's more efficient and faster to solve, so we could just choose that pair instead. This is called [Pair Choice](/improvement-guide/zzf2l/pair-choice).
diff --git a/pages/zh/tutorial/eo.mdx b/pages/zh/tutorial/eo.mdx
index fb8535e..a1b6463 100644
--- a/pages/zh/tutorial/eo.mdx
+++ b/pages/zh/tutorial/eo.mdx
@@ -46,8 +46,7 @@ Almost! This is the closest we can get, usually something like this:
@@ -89,8 +88,7 @@ Here we have a green-red edge. Let's press ▶️ and watch the green sticker, s
@@ -130,8 +126,7 @@ For example, this bad edge has a red sticker in the purple orbit, and a green st
@@ -192,8 +186,7 @@ After that, we can choose how to hold the cube. For example, orange center top,
@@ -210,8 +203,7 @@ Edges with those stickers are bad.
@@ -227,8 +219,7 @@ We found three bad edges so far, let's mark them with tape.
@@ -259,8 +249,7 @@ We've found all 6 bad edges! Here they are.
@@ -329,8 +317,7 @@ With `F2`, it's much simpler:
diff --git a/pages/zh/tutorial/eocross.mdx b/pages/zh/tutorial/eocross.mdx
index da30e49..68ab6a9 100644
--- a/pages/zh/tutorial/eocross.mdx
+++ b/pages/zh/tutorial/eocross.mdx
@@ -20,10 +20,8 @@ A solved EOCross looks like this:
@@ -83,11 +81,10 @@ Then we can do `R'`.
Now we know how to move any cross edge to the bottom.
@@ -95,11 +92,10 @@ We could put all cross edges on the bottom, and it would look like this.
However, this is not a solved cross!
@@ -107,10 +103,8 @@ Our goal is to solve the cross pieces, which looks something like this:
@@ -130,12 +124,11 @@ Here's an example where we use these relationships to solve cross:
There are already two cross edges at the bottom, but they don't have the right relationship.
@@ -146,11 +139,10 @@ We can fix that by replacing the green-white cross edge with the blue-white cros
Move: `R`
@@ -163,11 +155,10 @@ We can do `D2 R'` to place the blue cross edge opposite to the green cross edge,
@@ -176,11 +167,10 @@ We can finish with `D L'`.
diff --git a/pages/zh/tutorial/ll.mdx b/pages/zh/tutorial/ll.mdx
index 76b93fb..db834b2 100644
--- a/pages/zh/tutorial/ll.mdx
+++ b/pages/zh/tutorial/ll.mdx
@@ -47,10 +47,9 @@ An important pattern for OCLL recognition is called **headlights:** a pair of ma
@@ -80,10 +79,9 @@ Like in OCLL, we look for headlights, but they look a bit different:
diff --git a/pages/zh/tutorial/zzf2l.mdx b/pages/zh/tutorial/zzf2l.mdx
index 6514f89..5362e55 100644
--- a/pages/zh/tutorial/zzf2l.mdx
+++ b/pages/zh/tutorial/zzf2l.mdx
@@ -32,23 +32,19 @@ The rest of the article does not require any knowledge of CFOP.
To complete the F2L, we need to solve four corners and four edges around the EOCross.
Each pair of matching corners and edges is called an **F2L pair**. For example, this is the front-right (FR) pair, scrambled up:
And that "gap" where a pair belongs to is called an **F2L slot**. So the FR pair belongs to the FR slot, shown above as an empty spot.
@@ -69,11 +65,9 @@ We call these two simplest ways **basic inserts**.
This is the **joined pair:** the two pieces of this F2L pair are joined together with the colors aligned.
Moves: `R U' R'`
@@ -92,11 +86,9 @@ This is the **split pair:** it looks like a joined pair that was split apart by
We can also solve this in three moves with this strategy:
Moves: `R U R'`
@@ -117,11 +109,9 @@ Here's the same F2L case on both the FR and FL pairs.
Front-right pair:
Moves: `R U2 R'`
@@ -129,11 +119,9 @@ Front-right pair:
Front-left pair:
@@ -166,10 +154,9 @@ To move a trapped piece to the top, we'll learn a general strategy.
As an example, the white-blue-orange corner is trapped in the FR slot.
Moves: `R U R'`
@@ -181,10 +168,9 @@ As an example, the white-blue-orange corner is trapped in the FR slot.
This strategy still works if both F2L pieces are trapped in the same slot:
Moves: `R U R'`
@@ -193,10 +179,9 @@ However, if exactly one piece is already at the top, there's a chance that it wi
For example, doing `R U R'` here will just trap the corner.
Moves: `R U R'`. Oh no, corner's trapped now!
@@ -208,10 +193,9 @@ Here, the first move is `R`, so then we move the pieces out of the R layer.
`U2` works. You could also do `U'`.
Moves: `R'`**`U2`**`R'`
@@ -225,10 +209,9 @@ This BR pair has both pieces trapped.
Let's lift the edge to the top.
@@ -241,10 +224,9 @@ Let's lift the edge to the top.
Then we can lift the corner to the top, but be careful because we now have the edge at the top.
@@ -263,21 +245,19 @@ The pair is now at the top, but if they're "touching" then we want to separate t
The pair is **touching** if they're right next to each other like this:
This pair is separated, which is what we want:
To separate a touching pair, there are four easy moves:
@@ -295,10 +275,9 @@ For example, in this situation we can do:
4. `R'` to move the FR slot back down.
Moves: `U R U2 R'`
@@ -309,10 +288,9 @@ For example, in this situation we can do:
Here's the FL pair, the pieces are touching and the BL slot is also unsolved.
@@ -344,10 +322,9 @@ We'll setup a joined pair.
Here's the strategy alongside an example:
Moves: `U2 R U R'`
@@ -365,10 +342,9 @@ Then we'll have a joined pair.
Here's the FL pair, the corner has the white D sticker on the top side so it's Case A.
@@ -393,10 +369,9 @@ The **hiding spot** for the corner is the position that is an `R2` or `L2` move
Here's the strategy for Case B:
Moves: `U' R U2 R'`
@@ -414,10 +389,9 @@ Now we'll have a joined pair!
This is the BL pair. Both pieces have green on the top, so this is Case B.
@@ -445,20 +419,18 @@ The split pair is also like this, so we'll set up to the split pair.
There are only two cases. It's either a split pair which is our goal (you can see that it's 1 move away from being joined).
Or, it's not a split pair. We'll follow a strategy very similar to Case B.
Moves: `U' R U R'`
@@ -482,10 +454,9 @@ Imagine we did an `R2`. That position would move to the top-front-right.
That's the hiding spot.
Moves: `U2 R' U' R`
@@ -512,10 +483,9 @@ The FR slot is in the R layer, so we can do a `U2` to move the pair out of the R
`U'` also works.
@@ -526,11 +496,9 @@ Now it's time to do the basic insert. Here's the explanation from the [basic ins
3. Bring the solved slot back down. (`R'`)
Moves: `R U' R'`
@@ -538,11 +506,9 @@ Now it's time to do the basic insert. Here's the explanation from the [basic ins
Alternatively, if we chose `U'` instead of `U2` to position the pair, our basic insert will be like this:
Moves: `R U2 R'`
@@ -557,21 +523,18 @@ The corner needs to be above the slot we're solving, and that's the only positio
In this case, do a `U'` to move the corner above the FR slot, which the pair belongs to.
Now it's time to do the basic insert. Here's the explanation from the [basic inserts section](/tutorial/zzf2l#basic-inserts) again:
Moves: `R U R'`
diff --git a/postcss.config.js b/postcss.config.js
new file mode 100644
index 0000000..33ad091
--- /dev/null
+++ b/postcss.config.js
@@ -0,0 +1,6 @@
+module.exports = {
+ plugins: {
+ tailwindcss: {},
+ autoprefixer: {},
+ },
+}
diff --git a/public/assets/MethodDev/MethodDevelopmentLifeCycle.png b/public/assets/MethodDev/MethodDevelopmentLifeCycle.png
new file mode 100644
index 0000000..092f9c5
Binary files /dev/null and b/public/assets/MethodDev/MethodDevelopmentLifeCycle.png differ
diff --git a/public/logo-eoline.svg b/public/logo-eoline.svg
new file mode 100644
index 0000000..36a7ab2
--- /dev/null
+++ b/public/logo-eoline.svg
@@ -0,0 +1,276 @@
+
+
+
+
diff --git a/public/logo.svg b/public/logo.svg
index 36a7ab2..ab6357a 100644
--- a/public/logo.svg
+++ b/public/logo.svg
@@ -1,276 +1,21 @@
-
-
-
diff --git a/tailwind.config.ts b/tailwind.config.ts
new file mode 100644
index 0000000..9c3dc03
--- /dev/null
+++ b/tailwind.config.ts
@@ -0,0 +1,13 @@
+import type { Config } from "tailwindcss";
+
+export default {
+ content: [
+ // "./app/**/*.{js,ts,jsx,tsx,md,mdx}",
+ "./pages/**/*.{js,ts,jsx,tsx,md,mdx}",
+ "./components/**/*.{js,ts,jsx,tsx,md,mdx}",
+ ],
+ theme: {
+ extend: {},
+ },
+ plugins: [],
+} satisfies Config;
diff --git a/theme.config.tsx b/theme.config.tsx
index f10aaaa..b71bf90 100644
--- a/theme.config.tsx
+++ b/theme.config.tsx
@@ -3,7 +3,7 @@ import { DocsThemeConfig, useConfig } from "nextra-theme-docs";
import { useRouter } from "nextra/hooks";
import Image from "next/image";
import logo from "public/logo.svg";
-import Link from "next/link";
+// import Link from "next/link";
import { authorsMap, backToTopMap, defaultDescriptionMap, editTextMap, feedbackLinkMap, footerMap, gitTimestampMap, logoTextMap, searchPlaceholderMap, tableOfContentsMap, titleTextMap } from "translations/site";
import { useTranslation } from "translations/useTranslation";
@@ -12,7 +12,7 @@ const config: DocsThemeConfig = {
const logoText = useTranslation(logoTextMap);
return (
<>
-
+ {logoText}
)
@@ -36,7 +36,6 @@ const config: DocsThemeConfig = {
i18n: [
{ locale: 'en', name: 'English' },
// { locale: 'fr', name: 'Français' },
- // { locale: 'he', name: 'עִברִית', direction: 'rtl' },
// { locale: 'zh', name: '中文' },
],
head() {
diff --git a/translations/ReconCollection.tsx b/translations/ReconCollection.tsx
index 80b8a58..cb94f3c 100644
--- a/translations/ReconCollection.tsx
+++ b/translations/ReconCollection.tsx
@@ -8,7 +8,6 @@ import { Translation } from "./types";
export const jumpToVideoTimestampMap: Translation = {
en: "Jump to video timestamp",
fr: "Jump to video timestamp",
- he: "Jump to video timestamp",
zh: "Jump to video timestamp",
};
@@ -16,7 +15,6 @@ export const jumpToVideoTimestampMap: Translation = {
export const previousReconMap: Translation = {
en: "Previous",
fr: "Previous",
- he: "Previous",
zh: "Previous",
};
@@ -24,7 +22,6 @@ export const previousReconMap: Translation = {
export const nextReconMap: Translation = {
en: "Next",
fr: "Next",
- he: "Next",
zh: "Next",
};
@@ -45,14 +42,6 @@ const colors: Translation<{ [color in Color]: string }> = {
orange: "orange",
red: "red",
},
- he: {
- white: "white",
- yellow: "yellow",
- blue: "blue",
- green: "green",
- orange: "orange",
- red: "red",
- },
zh: {
white: "white",
yellow: "yellow",
@@ -68,20 +57,17 @@ const colors: Translation<{ [color in Color]: string }> = {
export const usePreferredSolvingOrientationMap: Translation = {
en: "Use your preferred solving orientation",
fr: "Use your preferred solving orientation",
- he: "Use your preferred solving orientation",
zh: "Use your preferred solving orientation",
};
export const topColorMap: Translation<(color: Color) => string> = {
en: (color) => `${colors.en[color]} top`,
fr: (color) => `${colors.fr[color]} top`,
- he: (color) => `${colors.he[color]} top`,
zh: (color) => `${colors.zh[color]} top`,
};
export const frontColorMap: Translation<(color: Color) => string> = {
en: (color) => `${colors.en[color]} front`,
fr: (color) => `${colors.fr[color]} front`,
- he: (color) => `${colors.he[color]} front`,
zh: (color) => `${colors.zh[color]} front`,
};
diff --git a/translations/ReconViewer.tsx b/translations/ReconViewer.tsx
index c31f5aa..8a816c0 100644
--- a/translations/ReconViewer.tsx
+++ b/translations/ReconViewer.tsx
@@ -7,7 +7,6 @@ import { Translation } from "./types"
export const scrambleTextMap: Translation = {
en: "Scramble:",
fr: "Scramble:",
- he: "Scramble:",
zh: "Scramble:",
}
@@ -15,7 +14,6 @@ export const scrambleTextMap: Translation = {
export const solutionTextMap: Translation = {
en: "Solution:",
fr: "Solution:",
- he: "Solution:",
zh: "Solution:",
}
@@ -24,14 +22,12 @@ export const solutionTextMap: Translation = {
export const solveIndexMap: Translation<(solveNumber: number) => string> = {
en: (solveNumber) => `Solve #${solveNumber}`,
fr: (solveNumber) => `Solve #${solveNumber}`,
- he: (solveNumber) => `Solve #${solveNumber}`,
zh: (solveNumber) => `Solve #${solveNumber}`,
}
export const reconstructedByMap: Translation<(reconstructor: string) => string> = {
en: (reconstructor) => `Reconstructed by ${reconstructor}`,
fr: (reconstructor) => `Reconstructed by ${reconstructor}`,
- he: (reconstructor) => `Reconstructed by ${reconstructor}`,
zh: (reconstructor) => `Reconstructed by ${reconstructor}`,
}
@@ -39,6 +35,5 @@ export const reconstructedByMap: Translation<(reconstructor: string) => string>
export const notesTextMap: Translation = {
en: "Notes:",
fr: "Notes:",
- he: "Notes:",
zh: "Notes:",
}
\ No newline at end of file
diff --git a/translations/site.tsx b/translations/site.tsx
index 03a7904..8ab81c5 100644
--- a/translations/site.tsx
+++ b/translations/site.tsx
@@ -5,70 +5,60 @@ import { Translation } from "./types"
export const titleTextMap: Translation = {
en: "ZZ Method",
fr: "ZZ Method",
- he: "ZZ Method",
zh: "ZZ Method",
}
export const defaultDescriptionMap: Translation = {
en: "Guide to the ZZ Speedsolving Method",
fr: "Guide to the ZZ Speedsolving Method",
- he: "Guide to the ZZ Speedsolving Method",
zh: "Guide to the ZZ Speedsolving Method",
}
export const feedbackLinkMap: Translation = {
en: "Question? Give us feedback →",
fr: "Question? Give us feedback →",
- he: "Question? Give us feedback →",
zh: "Question? Give us feedback →",
}
export const editTextMap: Translation = {
en: "Edit this page",
fr: "Edit this page",
- he: "Edit this page",
zh: "Edit this page",
}
export const tableOfContentsMap: Translation = {
en: "On This Page",
fr: "On This Page",
- he: "On This Page",
zh: "On This Page",
}
export const backToTopMap: Translation = {
en: "Scroll to top",
fr: "Scroll to top",
- he: "Scroll to top",
zh: "Scroll to top",
}
export const searchPlaceholderMap: Translation = {
en: "Search documentation...",
fr: "Search documentation...",
- he: "Search documentation...",
zh: "Search documentation...",
}
export const logoTextMap: Translation = {
- en: "ZZ Method",
- fr: "ZZ Method",
- he: "ZZ Method",
- zh: "ZZ Method",
+ en: "Cubing Methods",
+ fr: "Cubing Methods",
+ zh: "Cubing Methods",
}
export const authorsMap: Translation<(authors: string) => string> = {
en: (authors: string) => `By ${authors}`,
fr: (authors: string) => `By ${authors}`,
- he: (authors: string) => `By ${authors}`,
zh: (authors: string) => `By ${authors}`,
}
export const gitTimestampMap: Translation = {
en: "Last updated on",
fr: "Last updated on",
- he: "Last updated on",
zh: "Last updated on",
}
@@ -87,6 +77,5 @@ const CubingJsLink = () => ( = { [key in Language]: T }
diff --git a/utils/classnames.ts b/utils/classnames.ts
new file mode 100644
index 0000000..79c196e
--- /dev/null
+++ b/utils/classnames.ts
@@ -0,0 +1,2 @@
+export const cn = (...classNames: any[]) =>
+ classNames.filter(Boolean).join(" ");