⁠

⁠ is an esoteric programming language created by CreeperBomb (interact in such a way to use diction in order to achieve the result of conversation or other form of communicating an idea or group of ideas between individuals including myself) that only uses the zero-width characters U+2060 and U+FEFF for operators. Due to the invisible nature of the name, "WJ" (from the name's character's abbreviation) may be used when necessary. However, keep in mind that "WJ" is technically incorrect, and thus won't be used here.
==Semantics & syntax==
Programs in ⁠ take place on an infinite tape of cells, plus one special "operation" cell, that can store nonnegative integers. While cells usually start with a value of 0, the user may input anything by changing cell values (note that the user can "change" a cell to have a value of 0). The states of the cells that were changed during the running of the program are outputted once the program halts, which occurs on undefined lines.
Character	Action
U+2060 	Increment the operation cell, unless this is the TREE(3)*nth instruction in a line. If it is such TREE(3)*nth instruction, decrement the cell by TREE(3), unless the cell's value is less than TREE(3). If this is the case, jump by (the current (not operation) cell's value-floor(TREE(3)÷2)) lines in the code. "n" in TREE(3)*nth represents any positive integer.
U+FEFF 	If the operation cell's value mod 4 is 0, do nothing. If its value mod 4 is 1, move right g64 cells on the tape. If its value mod 4 is 2, move left googolplex cells. If its value mod 4 is 3, set the current cell's value to (operation cell's value-3)÷4 and the operation cell's value to (current cell's value*4)+3.
In addition to these, the newline character U+000A is used to seperate lines. When the program reaches the end of a line, it will go to the next line. If that line would occur after the code ends, meaning that the line is undefined, the program will halt. The first line is line 0. Blank lines aren't considered undefined.
==Turing completeness==
⁠ is very likely Turing complete. For this proof, we will denote U+2060 will +, U+FEFF with *, and for any operation/operation group N say Nv represents v Ns. First, we will assume that the user doesn't change the operation cell. The next step is to create increments and decrements that can be done whenever. Let's define "-" to be +TREE(3). If "-" is on a (1+TREE(3)*n)th instruction, this will do TREE(3)-1 increments and one decrement by TREE(3). The total effect of "-" in that case is a decrement by one. Now, for "<" & ">", which will move one cell left or right. Because Graham's number is odd while googolplex is even, there is a finite series of adding Graham's number and subtracting googplex to get -1 and 1. Since TREE(3) is far, far, far, far above these two, this series should have a length far below TREE(3), even with the +s required for shifting between the googolplexes and Graham's numbers accounted for. After these, a few more +s can be used to shift the operation cell back into a multiple of four, and then, after a bunch of *s doing nothing, you hit the TREE(3)th instruction. Now, since alignment with TREE(3) has been regained, you can use some of the -s we defined earlier to undo all of the incrementing. These -s serve the purpose of cancelling out the value change. Now, let's define "%". "%" will set the current cell's value to (the operation cell's value÷4) and the operation cell's value to (the current cell's value*4). To do this, we have "%" be +++*+*TREE(3)-5-4. This achieves our definition and TREE(3) alignment. Finally, we can define "ʌ" incrementation & "v" decrementation. "ʌ" will be %++++*TREE(3)-4% & "v" will be %-4%. Thanks to insistence to keep things' lengths integer multiplies of TREE(3) (TREEven?), these will always increment or decrement the current cell unless something gets messed with. However, we haven't proved Turing completeness with just our "<", ">", "ʌ", & "v" yet. For that, we'll add "j" for jump, and have it be *TREE(3)-1+. With these five symbols and our line semantics, we have a Turing complete language. And since these all came ⁠ operators, ⁠ must be Turing complete if the very likely true case of if adding Graham's number and subtracting googolplex to get to 1 & -1 in less than TREE(3) terms is possible.
==Example programs==
These will use the notation invented in the "Turing completeness" section to make programs more storable. These won't be written in code blocks as that breaks subscripts.
Cat program:
Truth machine:
ʌfloor(TREE(3)÷2)+1j
ʌʌj
v
ʌvfloor(TREE(3)÷2)>ʌfloor(TREE(3)÷2)j
vfloor(TREE(3)÷2)+3
This might help for getting the full truth machine program in pure ⁠ ⁠ ⁠ ⁠ ⁠
Category:Languages
Category:Cell-based
Category:2023
Category:Turing complete
Category:Turing tarpits
Category:Unusable for programming
Category:Unimplemented