icon icon.gif
Dedicated to Yasmina Llaveria del Castillo
Sudoku game and solver totally written in DHTML.

You can donate using PayPal at sf.net/donate/index.php?group_id=173641
If the donation link doesn't work, try by clicking the button below:

Please, support this project!



Play on-line


Possible future ports

Stores (Markets) and Links


Some software used

Use it in your web site

(or n)
The desired sudoku (numbers already set by the game that cannot be changed by the user).
The value must be a string of numbers (0 to 9) and each digit will belong to a sudoku cell (starting from left to right and up to down). Zero (0) means an empty cell. All last zeros from the string are not necessary and can be omitted if there is no other different number (1 to 9) after them (in this case we don't need to use a string of 81 digits).
Example: sudoku=000006789123456789123456789123450000003456789123456789123456789123456789123000000 (or n=000006789123456789123456789123450000003456789123456789123456789123456789123)
(or d)
The desired introduced numbers (numbers already set by the user which the user can change).
The value must be a string of numbers (0 to 9). The sudoku will be filled with these numbers starting from the first empty cell. Each digit of this string belongs to an empty cell present in the sudoku (starting from left to right and up to down) without having in mind the cells which are not empty. Zero (0) is used to jump an empty cell without affecting it (leaving it empty). All last zeros from the string are not necessary and can be omitted if we don't want to affect more cells.
This parameter will be ignored if the parameter sudoku (or equivalent) is not given.
Example: introduced=00123000 (or d=00123)
(or l)
Desired language for the game.
Unless there are new translations for the game, possible values are ca, en, es, zh (Catalan, English, Spanish and Chinese simplified respectively).
It is better not to use this parameter since by default the game will detect the language of the user automatically. If we use a language that the game does not support, the parameter will be ignored.
Example: language=es (or l=es)
(or p)
If the value is set to no (or n), the panel which is placed below in the game (with the menu for the initial numbers) will be hidden when the game starts. Otherwise, any other value (or when the parameter is not set) will make that panel show (which is the default behaviour).
Example: show_panel=no (or p=n)
(or a)
If the value is set to no (or n), the autosave (which saves all game progress and options set automatically) will be disabled. Otherwise, any other value (or when the parameter is not set) will enable the autosave (which is the default behaviour).
Example: autosave=no (or a=n)
(or i)
The initial numbers (from 0 to 81) used to create a random sudoku when the game starts.
This parameter will be ignored if the parameter sudoku (or equivalent) is given.
By default is 38.
Example: initial_numbers=57 (or i=57)
(or x)
Defines whether the game should be stretched to fit the screen (or its container or any view port used) or otherwise it should keep a proportional aspect ratio (using proportional or p as value).
By default the game stretches.
Example: aspect=p (or x=p)
(or s)
Seconds that the game will show the solution calculated on the fly.
It must be an even number from 0 to 300 (recommended at least 6 or more).
By default is 8.
Example: solution_seconds=11 (or s=11)
(or t)
Disables some effects to make the game faster in some old devices (it will look uglier!).
We can set the value to medium (or m) to disable some expensive effects as box-shadows and others which can slow quite a bit some old machines. To disable almost all effects, for very slow devices, we can set the value as ultra (or u).
By default it will use all possible effects.
Example: lightweight=medium (or t=m)
(or h)
Enables or disables some help that makes the game easier for the user.
If we use the value set to all (or a), the user will receive help to avoid repeating both numbers that were already written in the sudoku (fixed numbers set by the game) and numbers which the user has already entered before.
If we use the value set to fixed_only (or f), the user will receive help to avoid repeating just the numbers which the game has already set for the sudoku (without paying attention to the numbers set by the user).
Any other value will disable any kind of help.
By default, the value used is fixed_only.
Example: help=all (or h=a)
If we want to use this parameter, it must contain the following parameter values (using single letter values is mandatory when is possible) but compressed in this order: value for p, value for a, value for i, value for x, value for s, value for t and value for h.
All those seven (7) parameter values must be used, without omitting any of them, and always in the same order. We don't use any character to separate them. In the case we do not want to specify a language, in order to force automatic detection, we should use two characters that does not belong to any language (as for example k=--yy38s8nf, where "--" cannot be a language).
Example: k=esyy38s8nf (this would mean l=es, p=y, a=y, i=38, x=s, s=8, t=n and h=f)
This parameter allows you to compress the URL using this format:
Where "sudoku-in-base-69" is the sudoku compressed in base 69, "introduced-numbers-in-base-69" are the introduced numbers in base 69 and "k" are the options of the game compressed the same way as in the "k" parameter. All of the three values are optional. You can learn about how to compress to base 69 below.
c=1bsV-HiiFT-1hiLx-dn2o2-8uvyB-365)v-3lXNx-SOTKj-3)5*h_4SR*P_esyy38s8nf (with sudoku, itroduced numbers and options)
c=1bsV-HiiFT-1hiLx-dn2o2-8uvyB-365)v-3lXNx-SOTKj-3)5*h__esyy38s8nf (with sudoku and options. Note the double "_")
c=1bsV-HiiFT-1hiLx-dn2o2-8uvyB-365)v-3lXNx-SOTKj-3)5*h_4SR*P (with sudoku and introduced numbers)
c=1bsV-HiiFT-1hiLx-dn2o2-8uvyB-365)v-3lXNx-SOTKj-3)5*h (with sudoku only)
c=_4SR*P_esyy38s8nf (with introduced numbers and options. Note the "_" at the beginning)
c=_4SR*P (with introduced numbers only. Note the "_" at the beginning)
c=__esyy38s8nf (with options only. Note the double "_" at the beginning. In this case it would be better to just use the "k" parameter)

Explanation about base 69 compression:
Base 69 uses 69 different characters to represent numbers. The following are the existing characters in base 69 and their corresponding value in decimal system (ten base):
0 = 0
1 = 1
2 = 2
3 = 3
4 = 4
5 = 5
6 = 6
7 = 7
8 = 8
9 = 9
A = 10
B = 11
C = 12
D = 13
E = 14
F = 15
G = 16
H = 17
I = 18
J = 19
K = 20
L = 21
M = 22
N = 23
O = 24
P = 25
Q = 26
R = 27
S = 28
T = 29
U = 30
V = 31
W = 32
X = 33
Y = 34
Z = 35
a = 36
b = 37
c = 38
d = 39
e = 40
f = 41
g = 42
h = 43
i = 44
j = 45
k = 46
l = 47
m = 48
n = 49
o = 50
p = 51
q = 52
r = 53
s = 54
t = 55
u = 56
v = 57
w = 58
x = 59
y = 60
z = 61
. = 62
~ = 63
! = 64
' = 65
( = 66
) = 67
* = 68

Note the difference between capitalized letters and lower-case ones.

Let's imagine we have the following sudoku (following the rules of the "n" parameter):

First, we need to have the sudoku with all numbers (81 in total). So we fill the lost zeros at the end (remember that the "k" parameter allows to avoid writing zeros at the end of the sudoku):

Now, we split the sudoku in pieces of 9 numbers each using a hyphen ("-"):

The last step consists in transforming each piece into base 69 (we still keep the hyphens):
Note 1: if any piece has zeros (0) on its left, they can be omitted: KRIV would be the same as 00KRIV.
Note 2: in the case we had pieces which are empty (0), they do not need to be written. So 47NZt-HjcW.-U(!5Z-ZKH3j-QY0qX-5o(Ec-1q'LY-0-998I0 and 47NZt-HjcW.-U(!5Z-ZKH3j-QY0qX-5o(Ec-1q'LY--998I0 would be the same (note the double hyphen).
Note 3: in the case we had pieces which are empty (0) at the end, they do not need to be written and we do not even need their hyphen. So 47NZt-HjcW.-U(!5Z-ZKH3j-QY0qX-5o(Ec-1q'LY-0-0 and 47NZt-HjcW.-U(!5Z-ZKH3j-QY0qX-5o(Ec-1q'LY would be the same.

As you can see, the original sudoku had 75 characters and now just 53. We have saved 22 characters!

To compress the introduced numbers we just need to follow the same rules starting from the value of the "d" parameter.

Here you have a simple decimal to base 69 (and vice versa) converter that you can use to convert each piece:
Base 10:
Base 69:
Live example:

Translate into another language

Contact me

Please, support this project!
Fork me on GitHub