Glyphic Solitude

This game will teach you to recognize the hexadecimal numbers represented by the binary patterns of the elements of a glyph (or it will drive you mad, one or the other ... or both). I figure that if you couldn't handle complexity you would never have gotten this far.

After I played about twenty games I found it slightly easier to translate the glyphs into numbers (Your Mileage May Vary). I don't believe that you are likely to win until you start to see the glyphs as numbers instead of just semi-random splotches.

Incidentally, I credit (or blame) my ability to create vast intricate improbable animated structures to my early exposure to this version of solitaire. I'm telling you this because I won't be held responsible if you expose some impressionable young child to this game and they end up like me. Consider yourself warned.

FYI: Ideally, you should read this tutorial on a "big screen" device (like a personal computer) and follow along by exploring actual game moves (on your hand-held device) for each section.


The object of the game it to arrange all of the Cards into four descending Runs.

Tactics and Strategy

The main points:

Things which are occasionally very useful:
Strategies for 'seeing' the cards properly:
Ways to avoid stupid mistakes:
How to stave off the madness:


We will be using standard "card playing" terminology,

Physical Game Mechanics

Historical Perspective

This game is descended from a version of a Solitaire card game called "Once in a Thousand Years". I assume that it was given this name because that was the frequency of winning. While testing the game I lost 25 games before I finally won the first one. Winning is certainly possible, but it may not happen anytime soon, dear reader.

Caution: This game will often be utterly insoluble.

My mother added the following rules to make the game (slightly) less frustrating and more playable:

I removed the 'face-down' hidden cards (one row in the original game), and modified the Deck to make it compatible with Instrumentation. The difficulty decrease (eight columns instead of seven) and increase (sixteen cards per Suit instead of thirteen) roughly balance each other out (7/16 = 6/13 - .024 [truncated]). It is still a hard game to beat, but it is also exhilarating when you see how you can recursively restructure a chaotic pile of cards into groups of organized sequences (for very small values of exhilaration).

Apparently, some people call this game 'Spiderette', but I don't really have time to deal with that just now.


Here are all of the Cards, in ascending order from zero to 'F' (or fifteen). According to the Java color names, the Suits are Black, Magenta, Green and Red. If that doesn't help you, look at the single spoke on the right side of each Card.

all the Cards

The names of the (right side) Suits are Time (black #10), Object (magenta #20), State (green #40) and Self (red #80).

The pattern for the quantity of 'left side' spokes is 0 1 1 2  - 1 2 2 3 - 1 2 2 3 - 2 3 3 4 . The names of the (left side) Values are:

#0 - true or yes #1 - number #2 - relation #3 - sequence
#4 - thought #5 - mathematics #6 - standard #7 - size
#8 - meaning #9 - quantity #A - configuration #B - importance
#C - theory #D - test #E - guess #F - explanation

This means that the antipenultimate (third from the bottom) black Card in the second column would be called "the test of time". I assume that these Cards will withstand that test and replace the Tarot eventually. The game calls that Card the "D of time" because we only care about the numbers right now.

If you like, you can think of the "Lettered Cards" as Viscountess, Earl, Marquess, Duke, Queen and King (or Genus, Family, Order, Class, Phylum and Kingdom, if you prefer). I picked these names because too many of Santa's reindeer have names that start with 'D' or 'C'.

Below are all of the Runs, with each Suit split into two columns. Notice that the bottom Card in each column is plugged. This follows the same pattern as the Cards in the diagram above, except that the Cards are laid out in descending order from 'F' (or fifteen) to zero. If you can just combine these into four columns, you will have won. (Hint: green goes on green) The 'F' Card doesn't have to be the top card in a final Run, so these Runs can be joined in either order.

All the Runs

This is the initial game screen. I know it looks different that the actual game screen (no vertical column separators), but it is too good an example of potential card combinations to replace. I think this image does show why vertical column separators were needed.

Notice that one card is already plugged. The next move is yours.

Totally not confusing

Hint: put the 'A' on the 'B' on the 'C'

Test Results

I kept track of my progress while I was playing the game (or working hard on Quality Assurance). I also played a number of partial games that ended when I found an unplayable bug. I didn't count the partial games, because I don't know if I would have won or not, but they probably helped my learning curve. Well, that and the fact that I wrote the game code, designed the Cards, was very good with the original Card game and I have been working with binary numbers for almost forty years. (in other words, Your Mileage May Vary)

As the games progressed the moves (and my mistakes, just after I made them) became more obvious. Losing became less frustrating, because I knew that it wasn't my fault (except on those occasions where I made some incredibly stupid move, which is more annoying than frustrating).

At any rate, here are the results of my game testing.

games tested games won
Round 0
Round 1
Round 2
Round 3
Round 4
Round 5
Round 6
Round 7
Round 8
Round 9
Round A
Round B
Round C
Round D
Round E
Round F

Of course, these numbers obviously weren't entirely the result of my increasing familiarity with the game. There is an element of luck that determines if a given game is easy or impossible or (usually) just insanely difficult. No, seriously ...   I wrote the shuffling algorithm (it uses a Java Random.nextInt(64) call) and sometimes I'd still swear it is dealing me bad Cards on purpose. It does appear that winning two games in a row depletes your available luck and initiates a 'jinx' scenario.

back to the home page.