PlainCore

PlainCore is an esolang by User:yoyolin0409 and ChatGPT. Its aim is to solve as many problems as possible with as few instructions and few golf as possible. There are only 15 instructions in total, One of the instructions was even a comment. In addition, there are 6 magic words, 5 from Python and 1 original. (Here, "golf" refers to a method where a single action completes a problem directly.)
This language is Turing complete because it can actually replace the instructions in Brainfuck very well.

PlainCore

Designed by	User:Yoyolin0409 and ChatGPT
Appeared in	2026
Computational class	Turing complete
Reference implementation	Unimplemented
File extension(s)	.pc

Instructions

PlainCore has a memory cell of infinite length (theoretically) and a pointer (hereinafter referred to as the current cell). The length of the memory cell actually varies depending on the computer's performance and the language used by the translator. In fact, this function is auxiliary rather than primary.

set <name,name,name...> <value,value,value... or name,name,name...>

Create a variable named 'name' with the content 'value'. 'value' can be any text or number; text should be enclosed in quotation marks.

add <name,name,name...> <value,value,value... or name,name,name...>

As long as `name` is a numeric variable, plus the number represented by `value`, subtraction can be achieved by setting `value` to a negative number. It can also be used to connect text, In addition, you can use [] to add a variable to multiple values, or to add multiple values ​​to a variables.

mul <name,name,name...> <value,value,value... or name,name,name...>

If `name` is a numeric variable, multiply it by the number represented by `value`, In addition, you can use [] to multiply a variable to multiple values, or to multiply multiple values ​​to a variables.

div <name,name,name...> <value,value,value... or name,name,name...>

If `name` is a numeric variable, divide by the number represented by `value`, In addition, you can use [] to divide a variable to multiple values, or to divide multiple values ​​to a variables.

cmp <name1><Conditional expression><name2> [is False]

Comparing name1 and name2 to see if they meet the condition "is False" is unnecessary and will reverse the result. The condition can be = (equal), < (less than), > (greater than), <= (less than or equal to), or >= (greater than or equal to).Execution will only continue if the comparison result is "True"; otherwise, it will pause until the next "cmp" signal, at which point a new comparison will be performed before execution can resume. If you only write "cmp True", the result will definitely be True.

jmp <label or label_name>

Annoying, infamous "GOTO"

jnz <label or label_name> <Conditional expression>

GOTO with condition

in <name>

Input a string of characters and store it in a variable. The variable must be created first. If the variable is a literal variable, it will be stored directly as literal. If it is a numeric variable, it will only be entered if the input is a number; otherwise, an error will occur.

out <name>

Output variable content

nop

This is equivalent to a comment; all characters following it will be ignored. It is the only instruction that can be appended to another instruction.

label <label_name>

Set the current row number to <label_name>, then simply jmp to the reference to directly replace the row number.

trans <name1> <dict> <name2>

At this point, the dictionary is defined on the fly. The contents of `name1` are replaced with the contents of the dictionary and then output to `name2`. It's important to note that the order follows the order within the dictionary. For example:

set var1 "hi"
set var2 ""
trans var1 [hi:?,hi:!] var2
out var2

It will output "?", Furthermore, undefined text will remain as is.

quine

The only golf program in this language is a quine program.

tape <a s l r o i c>

`a` increments the current cell by one, `s` decrements the current cell by one, `l` moves the current cell to the left, `r` moves the current cell to the right, `o` outputs the current cell's number, `i` will prompt the user to enter a value and then store it in the cell, `c` will store the current cell value into the magic word __c__ for use in jnz's conditional expressions.

run <name>

If <name> is a literal variable, the text in <name> will be executed using the code in this language.

Magicword

\n

Like python, This shouldn't be considered a instructions, right?

\r

Like python, Cancel the all magic word after that

\"

Like python

\'

Like python

\\

Like python

__c__

See the "tape" description above.

Example

Hello, world!

set a "Hello, world!"
out a

99 bottles of beer

set num 99
set thing1 " bottles of beer on the wall,\n"
set thing2 " bottles of beer.\n"
set thing3 "Take one down, pass it around,\n"
set thing4 "Go to the store, buy some more,\n"
set thing5 "99 bottles of beer on the wall."
set no "No"
label a
set memory num
add memory thing1
out memory
add memory thing2
out memory
out thing3
add num -1
set memory num 
add memory thing1
out memory
jnz a num=1 is False
set memory num
add memory thing1
out memory
add memory thing2
out memory
out thing3
set memory no
add memory thing1
out memory
set memory no
add memory thing1
out memory
set memory no
add memory thing2
out memory
out thing4
out thing5

Quine

quine

Fibonacci sequence

set a 0
set b 1
set c 0
in c
label a
add a,b [-a,b],a
add c -1
jnz a c=0 is False
set d "Done!"
out d

Miscellaneous Notes

Of the 15 instructions 10 were ChatGPT's idea, while the remaining 5 were "div", "trans", "quine", "tape", and "run". However, even the 10 instructions generated by ChatGPT, as well as the [] format in `add` and `mul` and supported strings in `add`, were designed by me.

Theoretically, there are no upper or lower limits for numbers. In reality, it depends on computer performance and the language used by the interpreter.