☭

☭ (HAMMERANDSICKLE)

Paradigm(s)	Imperative
Designed by	User:Dragoneater67
Appeared in	2026
Memory system	Cell-based
Dimensions	One-dimensional
Computational class	Unknown
Reference implementation	C++
Influenced by	#b !I!M!P!O!S!S!I!B!L!E! Brainfuck
Influenced	⌬
File extension(s)	.hammerandsickle .☭ .has

☭ (a.k.a. HAMMERANDSICKLE) is an esoteric programming language with the goal of making programming nearly impossible.

Overview

The language is split into 2 phases of execution.

Phase 1

Phase 1 reads the source string character-by-character and executes a command. It has 8 internal registers:

1. a (uint8, does not affect phase 2)
2. w (uint8, does not affect phase 2)
3. h (uint8, the rolling encryption key for output)
4. q (uint8, the rolling encryption key for input)
5. p (unbounded, the memory pointer)
6. j (unbounded, the instruction count)
7. y (unbounded, the instruction pointer)
8. g (uint32, PRNG)

They are initialized with these values:

q = '?'
h = '#'
g = 89404137

The rest are initialized to $0$.
Before each command is executed g is recalculated using this formula:
$g_{\text{new}}=g\cdot 1664525+1013904223+a+w+h+q+p+c$
The command is determined by this formula ($o$ is the generated command, $c$ is the current character, $i$ is the position of the current character):
$o=\left(\left(\left((c\oplus q)+(i{\bmod {3}})+(g\gg 24)\right){\bmod {3}}\right)+3\right){\bmod {3}}$

Command	Operation
0	a += 3 w += 7 q -= 43 p -= 13 g ^= 0xCAFEBABE
1	a -= 2 w -= 5 q += 67 p += 17 g += a ^ w
2	Generates a character b using this formula: $b=\neg \left(\left((a\lor w)\land h\right)\oplus q\oplus (g\land {\text{0xFF}})\right)$ Subtracts $g\land 1$ from q Then, b is appended to the Phase 2 instruction tape. If b is invalid (not *, # or ?), g is set to 0xDEADBEEF.

(NOTE: p wraps around in the reference implementation because memory tape is bounded there)

Phase 2

Phase 2 is a virtual machine that executes the bytecode generated in phase 1. The virtual machine has:

• The unbounded memory tape (in the reference implementation the length is $10^{6}$)
• The unbounded instruction tape (in the reference implementation the length is $10^{6}$)
• The memory pointer (in the reference implementation it wraps around)
• The instruction pointer

The memory pointer is initially pseudorandom (value of p by the time phase 1 ended), while the instruction pointer is always initialized to $0$. Instructions are single ASCII characters, any other character is invalid and will result in a crash. Here is a quick overview of available commands:

Instruction	Condition	Operation
*	Instruction pointer is Odd	Adds 251 to the current memory cell, then moves the memory pointer right by 999983 positions.
	Instruction pointer is Even	Reads a character of input, XORs it with register q, and stores it in the current memory cell, then jumps back 3 steps.
#	Current memory cell is 0	Jumps back 7 steps, then modifies the instruction at that location by cycling it (* → # → ? → * → ...).
	Current memory cell is not 0	Moves the memory pointer left by 999979 positions, then adds 241 to the current memory cell.
?	Memory pointer is Odd	Outputs the character at the current memory cell XORred with the register h, then adds 239 to the current memory cell.
	Memory pointer is Even	If current memory cell is 0, skip forward 12 instructions. Otherwise, set both memory pointer to g and the instruction pointer to g mod j.

After each instruction is executed:

1. y is incremented by 1
2. q is incremented by 197
3. h is recalculated using this formula ($t_{p}$ is current memory cell value and $b_{y}$ is the current instruction):
   

$h_{\text{new}}=((g\gg 16)\land {\text{0xFF}})\oplus h\oplus (t_{p}\land (b_{y}\lor q))$

Examples

XKCD Random Number

iKrupBIJ2Ge7eJB6Wjav-stfem+d8zvCao9=a60U29ceE0KStlgieCyrUoCq0n = xkcd(36);

Shorter version

iKXXXSo[pLw7eP$K$W

(NOTE: Most text editors insert a newline at the end of a file, if it fails, that is probably the reason)

External resources

• The GitHub repository for ☭

See Also

• ⌬
• Malbolge