# Talk:Burn

Some other notes I remembered that may help people reconstruct the language:

• Upon loading the program, it's used to tile an entire infinite plane (possibly disrupted slightly; I can't remember); the program was the initial state for a certain algorithm for updating cells (making it a cellular automaton).
• Cell updates were irreversible; if a cell were ever changed, it was never changed back to its original value (although it might be changed again).

Unfortunately, that's not much to go on. --ais523 20:26, 16 December 2010 (UTC)

## Random Observations and Guesses

The frequency of each group of numbers is as follows, from most common to least common: 00 - 27 times
11 - 18 Times
01 - 8 Times
10 - 7 Times
02 - 1 Time
12 - 1 Time
20 - 1 Time
21 - 1 Time
03 - 1 Time
30 - 1 Time

Some other general observations:

• In ais523's note above, they mention "tiling an entire infinite plane." This leads me to believe that an infinite 2D array is created at some point, with each cell having a default value. Some of them possibly have different values than others (disrupted slightly.)
• The only characters that appear in Burn are 0, 1, 2, and 3. It is safe to assume that those characters are the only valid ones in Burn.
• The esolang has something to do with color, or it has the ability to print output in color.
• Each line of the automation is probably printed after it is computed, since rule110 works in a line-by-line fashion, and this interpreter contains an infinite playing field. Since the line is apparently infinite, though, I have no clue when it would decide to stop printing a line.

--Truttle1 (talk) 04:38, 3 April 2019 (UTC)

### One-eyed representations

So first let's make up some terms. The source code is a grid, 6 by 11 cells in size. There're two numbers in any cell. Let's call the left number "left-eyed" and the right one "right-eyed". So now, instead of one grid with two sized cells, we can have two grids with one sized cell.

Representation Left-eye view Right-eye view
Raw
```0 0 0 0 0 0
1 1 0 0 0 1
0 2 1 0 0 1
0 0 1 1 1 1
0 0 0 0 0 1
1 1 1 1 1 1
0 0 1 0 0 1
0 0 1 0 0 1
1 1 1 1 1 1
0 0 3 0 0 2
0 0 0 0 0 0```
```0 0 1 0 0 0
0 1 1 1 1 1
3 0 1 0 0 1
0 0 1 1 1 1
0 0 0 0 0 1
0 0 0 0 0 1
0 0 0 0 0 2
0 2 1 0 0 1
1 1 1 1 1 1
0 0 0 0 0 1
0 0 1 1 1 1```
Scheme
```      ;
─┐   │;
┗┐  │;
└──┤;
│;
──┬──┤;
│  │;
│  │;
──┴──┤;
3  ┃;
;```
```  │   ;
─┼──┐;
3 │  │;
└──┤;
│;
│;
┃;
┏┐  │;
─┴┴──┤;
│;
────┘;```

In the schemes:

• 0 is represented by a whitespace.
• 1 is represented by a thin line.
• 2 is represented by a thick line.
• 3 is represented by a three.

-- Dart (talk) 18:18, 5 December 2019 (UTC)

Given the top comment in the program, I've been assuming that what you call "left" and "right" is really "blue" and "green", and that other potential programs might possibly have a different set of colors. --Ørjan (talk) 03:00, 6 December 2019 (UTC)

If other programs might have different colours, that must mean somewhere in the code Blue and Green should be defined first. But it can't be in the grid because "the program is the initial state". So this brings up the possibilities that the comment is not actually a comment, colours are dynamic and can be changed by some pattern occurring, or simply that all programs have the same colours. -- Dart (talk) 09:18, 6 December 2019 (UTC)

The program could start with a grid and communicate with the other one to build the interpeter. --(this comment by Hex96 at 13:46, 7 December 2019‎ UTC; please sign your comments with ~~~~)

### Colours

I'm taking a creative guess that given the language name Burn, the colours BG = Blue Green (not Black Grey), are to be represented with the Red channel fully set, to give a fire-like visualisation as the cells switch states. From experimenting with 12bit colour values, `r = 0xF, g = 3G + 6, b = 3B + 4` gives nice distinguishable colour variants for the cells. Putting them in a table reveals that only some combinations are used in the example code, and the core 4 substantially more than those on the diagonal (using the frequency count above). -- Salpynx (talk) 05:42, 9 December 2019 (UTC)

 00 01 02 03 10 11 12 20 21 30

## Reverse engineering attempts

I'm going to take a guess, but even if I'm right it won't be exact yet. I'll use the notation (row, column) where row and column are indices starting at zero for the instruction pointer. It has a stack, a direction pointer similar to piet, and data pointer similar to brainfuck where each address in memory can store one bit. The program starts at (0, 3) and each iteration goes one pixel in the direction currently held in the direction pointer, I'm assuming it's initialized to down. If the color changes, it will do an operation depending on the new color. Black (notated 00) is a special color. If the instruction pointer is about to enter a black pixel, it doesn't change the instruction pointer and instead changes the direction pointer. In this case:

```Going into
this instruction
VV
00 01 00
00 01 01
00 00 00
```

The direction pointer will be set to right. In this case:

```00 00 00
00 01 01 < Going into this instruction
00 01 00
```

The direction pointer will be set to down. If there are two directions the direction pointer can be set to, it will pop a value from the stack, and the direction pointer will be set accordingly. In this case:

```Going into         00 01 00
this instruction > 01 01 00
00 01 00
```

If it pops a zero, the DP will be set to up. Otherwise, it will be set to down.

Here is a table of the color I think I've figured out so far.

```01 = NOP
11 = PUSH
02 = POP
10 = Pop a value x and push (not x)
30 = Duplicate the top of the stack
```

With this table, the example program sets address 0x0000 to 1 and exits the top half of the program. Hope this helps. --aithecomputerguy --(this comment by aithecomputerguy at 17:48, 7 June 2014‎ UTC; please sign your comments with ~~~~)

FWIW, I think this guess is inconsistent with the additional information ais523 gave above. --Ørjan (talk) 11:32, 2 December 2014 (UTC)

There is not a ‘23’, what would that do? --(this comment by Hex96 at 18:20, 5 December 2019‎ UTC; please sign your comments with ~~~~)

### I think I got the main parts down

I think the first line adds a square or whatever to the top, the next 4 lines are if then statements, the next two is the else statement and the last 3 are the looping and changing the selected cell to all 3 created at the same time. That’s what I think is what is happening with the program. --(this comment by Hex96 at 16:16, 4 December 2019 UTC; please sign your comments with ~~~~)

I doubt it. This language is a cellular automaton, so it's highly unlikely that it has traditional `if ... then ... else` flow control sequences. And structures in the script don't seem 1D enough to allow something like that anyway. -- Dart (talk) 09:05, 5 December 2019 (UTC)
K thanks, I should have guessed that. I'm stupid, it's an esolang, not python on steroids --(this comment by Hex96 at 15:29, 5 December 2019‎ UTC; please sign your comments with ~~~~)

### Attempted programs

Hello, world

I think that a hello world program would be like this

```00 01  02  03  04  05 06 07  08  09  10  11  setting up variables
80 80  80  80  80  80 80 80  80  80  80  80  saying that they are ascii values
72 101 108 108 111 44 32 119 111 114 108 100 the ascii values
40 40  40  40  40  40 40 40  40  40  40  40  prints the var underneath
00 01  02  03  04  05 06 07  08  09  10  11  the var underneath
```

I realised this would probably be wrong because as said by Trutle1 it is safe to assume that the only valid syntax is 0, 1, 2 and 3. --(this comment by Hex96 at 18:58, 4 December 2019 UTC; please sign your comments with ~~~~)

if you could create any text through the program, that would be cool. --(this comment by Hex96 at 10:11, 6 December 2019‎ UTC; please sign your comments with ~~~~)

### Phoney Burn

Here's my not-very-serious attempt to create an interpretation for this code as a Rule 110 implementation: User:Salpynx/Phoney_Burn_01. It's more of a generic 1D automaton encoding than the 2D automaton I think Burn probably is, but it was an interesting exercise. Maybe it'll spark some ideas for more serious reverse engineering, or other creative solutions. -- Salpynx (talk) 10:08, 9 December 2019 (UTC)

### a slightly more serious attempt

burn may have a not feature. If that is true then my guess is this:

The first line will start a nested loop.

the second and third and forth line and so on will do nots and loops to decide the cells value.

the next line will make that cell appear. The final line end the nested loops.

this program could do a rule 110 interpreter but slightly different:

```00 00 01 00 00 00
10 11 01 01 01 11
03 20 11 00 00 11
00 00 11 11 11 11
00 00 00 00 00 11
10 10 00 10 10 11
00 00 10 00 00 12
00 02 11 00 00 11
11 11 11 11 11 11
00 00 30 00 00 21
00 00 01 01 01 01
```

Original:

```
00 00 01 00 00 00
10 11 01 01 01 11
03 20 11 00 00 11
00 00 11 11 11 11
00 00 00 00 00 11
10 10 10 10 10 11
00 00 10 00 00 12
00 02 11 00 00 11
11 11 11 11 11 11
00 00 30 00 00 21
00 00 01 01 01 01
```

also `21` may print the top value on the stack as ascii.

## PNG of the program

Here's a PNG of what the program might look like. To me, it sort of looks like there's a path of 11's at the right, a short path of 01's at the bottom, another short path of 10's, and the 00's are empty spaces. Wonder what the odd ones out are doing there. --Quadril-Is (talk) 06:38, 13 December 2019 (UTC)