sixdegreesofwikipedia.com

Six Degrees of Wikipedia is a small browser-based tool that finds the shortest chain of hyperlinks connecting any two Wikipedia pages. You give it a starting article and a target article, and it searches Wikipedia's internal link structure for the fewest clicks between them. The site is a JavaScript-dependent side project: with scripting disabled, the page only shows a notice that JavaScript is required, so the tool cannot run at all in that state.

The idea behind the name

The name borrows from "six degrees of separation," the familiar claim that any two people are connected through a short chain of acquaintances. Wikipedia is a natural place to test that idea because its articles are densely interlinked: most pages link to many others, and those links form a navigable graph.

The tool treats Wikipedia as exactly that — a graph where:

• each article is a node, and
• each internal hyperlink between articles is a directed edge.

Finding the shortest path then becomes a standard graph-search problem rather than a trivia game.

How the shortest path is found

The site's own description states its purpose plainly: find the shortest hyperlinked paths between any two pages on Wikipedia. The mechanism follows from that goal.

1. Input: you specify two Wikipedia pages — an origin and a destination.
2. Traversal: the tool follows links outward from the origin, level by level, checking which pages are reachable in one click, then two clicks, and so on.
3. Result: the first time the destination appears, that chain is the shortest one, because every shorter distance was already checked.

This level-by-level expansion is breadth-first search. Its key property is that it guarantees the minimum number of links, provided the search is allowed to run far enough. A depth-first approach — plunging down one chain before trying another — would find a path but not reliably the shortest.

A concrete example

Suppose you want to get from an article about a small town to an article about a distant scientific concept. A human browsing might wander through a dozen clicks. The tool instead checks all one-link neighbors of the town article, then all two-link pages, and so on, and reports the first chain that lands on the science article. The answer is often surprisingly short, which is the appeal of the "six degrees" framing.

Why JavaScript is required

The page evidence is explicit: the site is a "little side project" that "requires JavaScript." When scripting is off, visitors see only an apology-style message rather than any content or results.

That behavior tells you where the computation happens. The path search runs in your browser rather than being precomputed on a server, so the page needs script execution to fetch link data, run the traversal, and render the chain. Practical implications:

• Enable JavaScript for the site's domain before expecting any output.
• Expect no fallback: there is no static HTML version of the results.
• Browser extensions that block scripts (ad blockers, privacy tools, script managers) can silently break the tool; allowlisting the site usually resolves it.

What this tool is and is not

It is worth separating the project from Wikipedia itself:

If you are looking for Wikipedia's own navigation or search features, this tool is not that; it is a third-party lens on Wikipedia's link graph.

When it is useful

The tool fits exploratory and educational use: satisfying curiosity about how tightly connected the encyclopedia is, demonstrating graph-search concepts with a real dataset, or settling a friendly "how many clicks apart are these two articles?" question. It is not a research database, and it does not modify or mirror Wikipedia content — it only reports paths through existing links.

To use it, open the site with JavaScript enabled, enter your two pages, and read the returned chain. If nothing happens, check script blocking first; that is the single most common reason the tool appears broken.

Six degrees of separation is the idea that any two people can be connected through a short chain of acquaintances—popularly, about six steps. On Wikipedia, the same idea applies to hyperlinks: because articles link to other articles, you can often travel from any starting page to any target page through a small number of clicks. Tools such as Six Degrees of Wikipedia find these shortest hyperlinked paths for you. The concept is useful for understanding how tightly connected a large link network is, and for testing whether a surprising connection between two topics is real or just a guess.

The core idea of six degrees of separation

The phrase describes social distance: two strangers are rarely more than a handful of introductions apart. The exact number is less important than the structure behind it—each person has many contacts, and those contacts have many contacts, so the number of reachable people grows very quickly with each step. That is why long chains are usually unnecessary even in very large populations.

The same logic applies to any network where nodes connect to other nodes. Wikipedia is one such network: articles are nodes, and internal links are edges.

How Wikipedia links form a network

Every Wikipedia article can link to other articles. Treat each article as a point and each internal link as a one-way connection, and the encyclopedia becomes a large directed graph. Finding a short path between two articles means finding a sequence of links that starts at one page and ends at the other.

Two details matter when interpreting results:

• Direction matters. A link from page A to page B does not guarantee a link from B back to A. A path found in one direction may not exist in the other.
• Path length is counted in clicks. A path of length 3 means three link-following steps, not three articles. The starting and ending pages are the endpoints of the chain.

Short paths exist because popular or broad articles act as hubs, and many specific articles link to them. A path often runs from a narrow topic up to a general one and back down to another narrow topic.

What a shortest-path result means

A shortest-path tool returns the minimum number of links needed to get from the start page to the target page, along with the specific sequence of pages. Read the result as a claim about this particular snapshot of Wikipedia's link structure, not as a permanent fact.

Path length can vary for several reasons:

• Links change. Editors add and remove links, so a path that exists today may not exist later.
• The graph is directed. The shortest path from A to B can differ from the shortest path from B to A.
• Hubs dominate. Pages with many outgoing links tend to appear in many short paths, which can make results look repetitive.

A short result does not prove the two topics are meaningfully related—only that the link structure allows a quick route between them.

Trying it with Six Degrees of Wikipedia

Six Degrees of Wikipedia is a side project that finds the shortest hyperlinked paths between any two pages on Wikipedia. Its page states that the interactive project requires JavaScript, so use a modern browser with JavaScript enabled. If scripting is blocked, the tool will not run.

A practical workflow:

1. Open the site in a browser with JavaScript enabled.
2. Enter a starting article and a target article.
3. Run the search and read the returned sequence of pages.
4. Note the number of steps and the direction of the search.

The expected result is a chain of article titles you can follow by hand.

Verifying a path manually

Because results depend on a live, changing site, confirm any path you plan to rely on:

1. Open the starting article on Wikipedia.
2. Find the link to the next page in the returned sequence and click it.
3. Repeat for each step until you reach the target article.
4. Count the clicks and compare with the reported length.

If a link is missing, the path may be outdated or the tool may have used a different link. This check also shows you which links carried the path, which is often the most interesting part.

Common sticking points

• Nothing happens when you search. JavaScript is probably disabled or blocked; the project explicitly requires it.
• The path looks implausible. Follow it manually—short paths often pass through broad hub articles that seem unrelated to either endpoint.
• Results differ between runs or directions. Link structures change and are directional, so treat any single result as one valid route rather than the only one.

Used this way, six degrees of separation on Wikipedia is less a fixed rule than a quick way to see how short the routes through a huge link network can be—and a prompt to check the route yourself.

Yes. CC0 assets can be used in commercial games without paying royalties or crediting the creator. CC0 is a public-domain dedication: the creator has waived copyright and related rights to the fullest extent allowed by law. That means you can copy, modify, redistribute, and sell work built on those assets — including in a game you charge money for.

This article explains what CC0 actually covers, how it differs from other Creative Commons licenses, and how to bring CC0 assets into engines like Unreal and Unity and tools like Blender, Maya, and 3ds Max.

What CC0 actually means

CC0 is not a license in the traditional sense — it is a waiver. When a creator applies CC0 to their work, they give up their copyright and agree not to enforce related rights. You are free to:

• Use the asset in personal, educational, or commercial projects
• Modify, remix, and build derivative works
• Distribute the asset or your derivative as part of a larger project
• Do all of the above without attribution

There is no requirement to credit the creator, no share-alike clause forcing you to open-source your game, and no non-commercial restriction. For a studio shipping a paid title, that combination is unusually permissive.

One practical caveat: CC0 applies to the rights the creator holds. It cannot waive third-party rights the creator never owned. A scanned statue, a branded product, or a recognizable logo in a texture may still carry trademark or personality-rights issues. Treat CC0 as clearing copyright, not as clearing everything.

CC0 vs. other Creative Commons licenses

The differences matter most when you are choosing assets for a commercial build. The table below summarizes the common variants.

| License | Commercial use | Attribution required | Share-alike | Notes for games | |---|---|---|---|---|---| | CC0 | Yes | No | No | Closest to public domain; safest for closed-source commercial titles | | CC BY | Yes | Yes | No | Fine for commercial use, but you must credit — plan for a credits screen | | CC BY-SA | Yes | Yes | Yes | Derivatives may need to be shared under the same license; risky for proprietary code/assets | | CC BY-NC | No | Yes | No | Excludes commercial projects; avoid for any monetized game | | CC BY-ND | Yes | Yes | No | No derivatives — you cannot modify the asset, which limits integration |

If your goal is a commercial game with no legal overhead, CC0 is the simplest choice. CC BY is workable if you can maintain attribution. Avoid NC and ND for anything you intend to sell or heavily adapt.

How CC0 assets fit into game engines and pipelines

CC0 libraries typically provide HDRIs, PBR textures, and 3D models. Each type has a natural place in a game pipeline.

HDRIs

HDRIs are high-dynamic-range environment maps. In Unreal, they are commonly used for sky lighting via a Sky Light set to use an HDRI cubemap or a Sky Sphere material. In Unity, they feed the skybox and the environment lighting in the Lighting window. You can also use them as reflection probes or as the basis for image-based lighting in Blender, Maya, or 3ds Max for look development before export.

Textures

PBR texture sets usually ship as albedo (base color), roughness, metallic, normal, and sometimes ambient occlusion or height maps. These drop directly into Unreal's material system or Unity's Standard/URP/HDRP shaders. Keep the resolution appropriate: 4K textures are useful for hero assets, but 1K or 2K is often enough for background props and saves memory.

Models

Static meshes and props can be imported as FBX or OBJ. Check the scale and pivot before placing them in a level. If the asset was authored for offline rendering, it may have very high poly counts — decimate or LOD it before use in a real-time scene.

Practical steps for importing and adapting assets

1. Download and verify the license. Confirm the asset page states CC0. Save a screenshot or the license text alongside the file.
2. Organize by type. Keep HDRIs, textures, and models in separate folders. A consistent naming convention (for example, env_forest_01_4k.hdr) saves time later.
3. Import into your engine. In Unreal, drag the FBX into the Content Browser and set up materials. In Unity, import the FBX and assign a PBR material, then wire the texture maps to the correct slots.
4. Adapt scale and orientation. Real-world assets may be authored in meters or centimeters. Check against a reference cube of known size.
5. Optimize. Reduce texture resolution where it will not be seen up close, generate LODs for models, and bake lighting where appropriate.
6. Test in context. Place the asset in a representative scene and check lighting, reflections, and performance before committing it to the project.

What CC0 does not cover

CC0 clears copyright, but a few things still deserve a second look:

• Trademarks and logos. A texture containing a recognizable brand mark is not automatically safe to ship.
• Recognizable people or property. A model of a real person or a distinctive building may raise personality or property-rights questions.
• Third-party content inside the asset. If a creator included someone else's work without permission, the CC0 dedication does not fix that.

For most generic assets — rocks, foliage, generic furniture, abstract HDRIs — these concerns are minimal. For anything depicting a real brand, person, or landmark, verify independently.

Documenting asset sources for teams and clients

Even though CC0 requires no attribution, keeping records is good practice. It protects you if a client or publisher asks for provenance, and it helps when a team member needs to know where a file came from.

A simple tracking sheet works:

Store this alongside your project files. If you later combine CC0 assets with CC BY assets, the sheet makes it obvious which ones need credit.

Bottom line

CC0 assets are safe for commercial games, require no attribution, and impose no royalties or share-alike obligations. The main work is practical: verify the license, check for third-party rights, import and optimize the asset for your engine, and keep a record of where it came from. Do that, and a CC0 library becomes a legitimate, low-friction source for production assets in Unreal, Unity, Blender, Maya, and 3ds Max.

In the Six Degrees of Wikipedia game, the shortest path is the smallest number of hyperlink clicks needed to get from one Wikipedia article to another. You start on a given page, follow only the links inside article text, and count each click as one step; the winning path is the one with the fewest steps. This definition applies to the game and to tools such as Six Degrees of Wikipedia, which searches Wikipedia's link network for the shortest hyperlinked route between two pages. It is a specific, clickable version of the general graph-theory idea of a shortest path.

The basic mechanics

Wikipedia articles form a directed graph: each article is a node, and each in-text hyperlink is an edge pointing from the article that contains it to the article it links to. A shortest path is a sequence of articles where every consecutive pair is connected by a real link, and no shorter sequence exists.

Two details matter in practice:

• Direction counts. Links are one-way. A links to B does not mean B links back to A, so a path that works in one direction may not exist in the other.
• Only article links count. Navigation elements, categories, references, and external links are not part of the in-text link graph used for path-finding.

A simple example: if the article "Banana" links directly to "Fruit," the path Banana → Fruit has length 1. If it does not, but Banana → Tropical fruit → Fruit exists, the shortest path is length 2 — unless some other article gives a one-click route.

Why short paths are common: six degrees of separation

Six degrees of separation is the idea that any two people are connected through a small chain of acquaintances. Wikipedia shows the same pattern in its link network: because articles are densely cross-linked, most pairs of pages are only a few clicks apart. A tool that searches for the shortest path is essentially testing that claim for a specific pair of articles — and often confirming it with a surprisingly small number.

This is why the game is interesting: the challenge is not whether a short path exists, but finding the shortest one, which usually means spotting a hub article (a country, a broad concept, a year, a profession) that links to many things at once.

How a shortest-path tool works

Six Degrees of Wikipedia describes itself as a way to "find the shortest hyperlinked paths between any two pages on Wikipedia." In use, the pattern is:

1. Input: a starting article and a target article.
2. Action: the tool traverses Wikipedia's link graph, expanding outward from the start page level by level and checking whether the target has been reached.
3. Expected result: one or more paths, each shown as an ordered list of articles you could click through, with the shortest path first.

The level-by-level search is what guarantees "shortest": the first time the target appears, no shorter route can exist. Note that the site's page states it requires JavaScript, so the search runs in the browser and will not work with scripting disabled.

When no path or a surprising path appears

If a tool reports no route, or a route much longer than you expected, check these causes before assuming a bug:

• Link direction. Try swapping start and target. A short path one way may be long or absent the other way.
• Exact page titles. Redirects, alternate spellings, and similarly named articles can send the search to the wrong node. Confirm you are using the exact article title.
• Recent edits. Wikipedia changes constantly; links added or removed since a path was recorded can break or shorten it.
• Scope of links. If you are playing by hand, remember that only in-text links count — a connection you "know" exists may live in a template or category instead.

Graph theory vs. the game

In graph theory, a shortest path is any minimum-length route between two nodes in a graph, and algorithms such as breadth-first search find it for unweighted graphs. The Wikipedia game is a concrete instance of that problem: unweighted (every click costs 1), directed (links are one-way), and defined only over article hyperlinks. Keeping that mapping in mind helps: the game's rules are not arbitrary, they are the graph's structure made playable.

An alg (short for algorithm) in speedcubing is a fixed sequence of moves that transforms a specific cube state into another — usually solving a case or advancing toward a solve. It is not a general math algorithm; it is a memorized motor routine. You need algs once you move past beginner layer-by-layer methods and start learning case-based systems like CFOP, Roux, or ZZ. This guide explains how algs are written, where to find them, and how to actually learn them.

What an alg actually is

An alg is a string of move instructions tied to a case — a specific arrangement of pieces. For example, an OLL alg assumes the last layer is oriented in a particular pattern; applied to that pattern, it produces a solved (or further-advanced) state.

Two consequences follow:

• An alg is case-specific. The same string applied to a different case gives a different, usually worse, result.
• An alg is orientation-specific. Most algs assume a defined cube orientation (e.g., the unsolved face facing you). Rotate the cube and the same moves no longer solve the case.

Reading alg notation

Standard notation lets you read any alg sheet. Each letter is a face; a prime (') means counterclockwise; a number means repeat.

A sample alg like R U R' U' reads: right clockwise, up clockwise, right counterclockwise, up counterclockwise. That four-move sequence is the "sexy move," the building block of many beginner and advanced algs.

Where to find algs by puzzle and case

Algs are organized by puzzle and by case. Speed Cube Database (speedcubedb.com) is one example of a free online database covering algorithms and reconstructions for 2x2 through 6x6, plus SQ1, Pyraminx, and Megaminx. Its keyword set — alg, algorithm, algsheet, cubing, speedcubing, fingertricks, video — reflects what such databases typically offer: alg sheets per case, fingertrick notes, and video demonstrations.

When searching for algs, match three things:

1. Puzzle (3x3, 4x4, etc.) — algs are not interchangeable across sizes.
2. Method/system (CFOP OLL/PLL, Roux CMLL, etc.) — the same case may have different algs per system.
3. Case name or diagram — use the visual to confirm you have the right one.

How to learn algs effectively

Memorizing the string is the easy part; making it fast is the work.

• Chunk the alg. Break it into 2–4 move groups rather than 15 separate moves. R U R' U' is one chunk, not four.
• Learn fingertricks. Each chunk maps to a finger motion (index push, ring pull, etc.). Databases that include fingertrick notes or video are more useful than raw text for this reason.
• Drill in isolation first. Repeat the alg slowly until it is accurate, then build speed. Accuracy before speed prevents locking in bad habits.
• Then drill in context. Apply it to scrambled cases so you practice recognition, not just execution.
• Space your practice. Short daily sessions beat one long cram; algs are muscle memory and decay without repetition.

Troubleshooting an alg that doesn't work

If an alg fails, check in this order:

1. Notation errors — a missed prime or a 2 read as a single turn is the most common cause.
2. Wrong case — confirm the piece arrangement matches the alg's diagram.
3. Cube orientation — verify which face is "front" and whether a rotation (x/y/z) is implied.
4. Wide vs. slice confusion — lowercase r is not the same as R or M.
5. Setup moves — some algs assume a preceding rotation or setup; check the full entry, not just the move string.

Work through these before assuming the alg itself is wrong — most failures are notation or orientation, not the sequence.