Aurora Methods
| ||||||||||||||||||||||
The Aurora Methods are a group of methods created by CrossPetrus that utilize recombinant f2l to force advantageous last layer cases.
On June 5, 2025, speedsolving member Neuro made this post:
“ A method / substep combo I've been thinking about for a bit:
1: FB 2: Cross 3: False F2L - form F2L pairs and surround the DR+R center block, occupying the DR-FR-BR-DFR-DBR space but not necessarily a solved 1x2x3 4: Recombinant LL prep - Fix F2L and do some LL influencing, like EO, OLL, CPEOLL, CLL, etc. 5: LL
Example up to recombinant LL prep:
Setup L2 F' D2 F U2 L2 F2 L2 F' U2 F' R2 U R' F' L D2 B' D F Moves (OB: 25)(OBQ: 31)(RB: 25)(E: 27) z' U' R2 U' r' x' u U F' //FB U r' R' U' r' U r' R2 //Cross U' R U2 R2 U' R2 U R' U2 R //False F2L
Of course, you can get to 2x2x3+final cross edge however you like, but FB->Cross seems efficient, ergonomic, and consistent.
Some common recombinant LL steps are
- Recombinant EOLL - fix F2L and orient LL edges, leaving ZBLL. Efficient and great alg quality, but problems with ZBLL recog and alg count
- Recombinant OLL - fix F2L and perform OLL, leaving PLL. Somewhat high alg count and questionable alg quality, but excellent recog
- Recombinant CPEOLL - fix F2L, perform CP, and perform EO, leaving 2GLL. Reasonable alg count and great alg quality, but very difficult recog
- Recombinant CLL - fix F2L and solve corners, leaving EPLL. Lowest alg count, good alg quality, but questionable recog time
Credit to Athefre for the recombinant step. It is very similar to his work on ACMLL and AOLL, just retooled and given a formal name.”
Inspired by this, CrossPetrus set out to create a method with a recombinant f2l. On August 27, CrossPetrus made this post in The New Method / Substep / Concept Idea Thread: “ So I've been working on a method for about a week, and it's called Aurora. It's not meant to be a super viable method, but something fun to do and solve the cube with, while not being 100% trash (or at least that was my goal). So here are the steps: 1. Build a petrus block and move it to dbl 2. build a 1x2x2 in dfR and do R' 3. put the back right pair in front right 4. solve the lxs slot in the front while doing "eo" (there will be one misoriented edge on the u layer because of the false f2l) there's 6 cases I have made all of the algs if you insert the edge in first 5. rcll: orient and permute the remaining edges while fixing f2l. 108 algs I genned all of them 6. Epll
Another variant is to solve CFOP diagonal pairs, do the R’ and third pair, fourth pair with eo (I should mention that this is rosiness, and thus the pair can be misoriented before insertion). Then end with your preferred rll technique (discussed below).
I am also entertaining the idea of doing more for peopair, maybe something like orienting the last layer into the basic case and then solving the cube in one look. Other things could also be possible. The possibilities will have to be tested and the algs genned, which I will be working on.
This is a work in progress and I am working on alg genning and seeing if there would be a better finish like rll (though there would probably be way too many algs, though if it were learnable I would do it (learnable being less than ~550 max)). -CrossPetrus (Yes, it had to start with a pertus block)”
This post outlines the method that became Aurora I. Eventually CrossPetrus would expand upon these ideas to make the Aurora II and Aurora III methods.
Variants
There are 3 variants of the Aurora Method, I, II, and III.
Aurora I
Aurora I’s steps are as follows:
- Build a Petrus block in dbl
- Build the dfR square in dbR
- Solve dFl while forcing 3 oriented edges on top
- RFOL (Solving f2l while forcing an oll skip, 27 algs)
- PLL (21 algs), or CP (2 algs)
- EPLL (4 algs), if CP was used in step 5
This is the first variant, and has an estimated movecount of 60+.
Aurora II
Aurora II’s steps are as follows:
- Build a 223 in db
- Build the dFr square in dFl
- Solve the dFL pair in dFR while forcing 3 oriented edges on U
- RFCP (fixing the f2l while orienting the edges and solving cp, 6 algs)
- 2gll (84 algs), or ocll (7 algs)
- Epll (4 algs) if ocll was used in step 5
The estimated movecount of this variant is 54-56 moves.
Aurora III
Aurora III’s steps are as follows:
- Build a 223 in dl
- Build the dfR square in dbR
- Solve the dBR pair in dFR
- RF2G (fixing the f2l while orienting the U layer edges while solving CP, 12 algs)
- 2gll (84 algs), or ocll (7 algs)
- Epll (4 algs) if ocll was used in step 5
Note: Since there is no eo control in step 3, it could very well be combined with step 2, which means it could take 4 steps.
The estimated movecount is 50, if not sub50. This variant has not had much exploration, so the movecount is not really set.
Pros
- There are not many algs required to achieve low movecounts with Aurora III
- Relatively easy to learn
- Decent movecount with Aurora II or III
Cons
- Not well researched
- Algs are difficult to recognize
- Ergonomics are bad, excluding ll
- You need a lot of time to get efficient at blockbuilding
Example Solves
Aurora II: Scramble: L2 B2 L2 F' L2 U2 R2 D2 F U2 L2 B' R' D2 R' B' L' U R' D2 B Solution:
y2 // inspection l U F' U2 L2 F' R U r2 U r' //223 (11/52) y U L' U' L F' U2 F' //fs (8/52) U2 R U R' U2 S' R U' R' S //peopair (10/52) U R U R' U R U' R' F' //rfcp (9/52) R U R2 U' R2 U' R2 U2 R U' R U' R' U2 // 2gll (14/52)
Aurora III: Scramble: L B' U' L' D B2 U2 F' L' R2 U L2 F2 U' R2 F2 D2 F2 U' L2 F' Solution:
z2 //inspection L' U' L2 U2 L' U' F' r' U2 r' U2 r2 //223 (12/40) U' R2 U2 R2 U2 F R' F' //dfR square (8/40) F' U2 F // pair (3/40) R f R' U R U' R' f' //rf2g (8/40) R' U2 R2 U R2 U R2 U2 R' //2gll (9/40)
External Links
https://docs.google.com/spreadsheets/d/1_JDuiGHdrwc3Rq48gIh5uFvZVN4J9b-G/edit?usp=drivesdk&ouid=100242630063312859715&rtpof=true&sd=true https://docs.google.com/spreadsheets/d/1CsaphjQUY6YjfMdRmXCfHFAh-HyMwxMC/edit?usp=drivesdk&ouid=100242630063312859715&rtpof=true&sd=true
