List of ideas

This is a list of ideas for esoteric programming languages or ideas for things related to esoteric programming.
The old version can be seen in the archive.
== Joke/Silly Ideas ==
Ideas that would go on the joke language list when completed.
* Combining brainfUck (not bf!) with Redcode, how crazy will that be, even though they are both Programming games
* A language that has gained sentience. And it's coming to get you.
* One where each command is in a different language
* A language that is procedurally generated based off of the unix timestamp, and its documentation updates as well.
** I am a genius, I am going to steal my own idea now.
** Tare is made using this idea.
* A language that criticizes every command you type and you have to keep bribing the interpreter
**Toddler would be a good fit with some adjustment. 
**How about Battlethought?
**possibly Anarchysm
* A Casino Viagra program language, where the programs are going to be caught by spam-filters and/or by anti-virus programs.
* A language based on the idea of communism. There would be only one great editor (a wiki or similar) and all programmers would write only one big program that does everything. There would be only one datatype that fits everything, so everything belongs to one single class.
** Functional programming is clearly based on the idea of communism. It elevates functions (things that do the work) to first class citizens, and it is a utopian endeavor aimed at abolishing all states. It is seen as inefficient and unpopular, but always has die-hard defenders, mostly in academia. Besides, ML stands for Marxism-Leninism. Coincidence? I think not. 
** It should be called Soviet Script and the one big program can be called the Universal Soviet Script Repository or USSR for short.
*** And they put all the packages together in one place (Hackage).
** It already exists and is called 'Web'.
** It already exists and is called 'Emacs'. Emacs is the one great editor, and the one big program (Emacs can do almost anything). The language is Emacs Lisp, which is functional, and almost everything is a list (the one great datatype/class). 
##Unfortunately
* When you scan in a poor quality sheet of text into Adobe and attempt to copy the text off of the page only for it to come out in complete gibberish. A language based on that.
** It already exists and is called 'Malbolge'.
* A language based on irony.
** A language based on irony in which there is actually no irony at all!
*** So, which should it be named, Alanis or Morissette?
*** Just like Soviet Russia.
**** In Soviet Russia, irony is lost on YOU!!! Oh, wait.
** How about a language that actually is ironic: each command does the exact opposite of what you'd expect. The print command is for input, x = y actually assigns y = x etc. Since you'd expect the commands to do the normal thing, and they do the opposite, that is ironic.
***But then you'd expect them to do that.
****So really, an ironic language wouldn't be a language at all and programs written with it aren't programs at all? Ultimately rendering the ironic language impossible to exist?
*****You would think so, but no.
****** A language that has macros but no way to run the normal commands, and the macros are designed in such a way that you basically have to implement another language into it, would that count?
****How about make it at a random line of code, it ironies itself again and turns back to normal. So you have to keep on spamming the interpreter the input code and hope that the RNG is on your side.
*** So x = y still causes x to be equal to y, it just does it in a different way from how most languages do it. (I'm reminded of that classic genie joke.)
** it could be called hipster, and we would have to use algorithms and techniques considered retro, obsolete or just bad in an ironic way. For example, to do a quick sort, you'd actually have to put in the code for bubble sort, followed by a comment line "REM PFFT, WHATEVER I WAS JUST BEING IRONIC" and everything is substituted by a quicksort function call at compile time. Furthermore, It would force you to use an IDE where Helvetica Neue Ultralight is the only font available.
* A language that requires you to use functions that are not called, and undefine all header files you will "not" use.
* "Undefined Behavior," a joke language whose specification is intentionally incomplete. Example instructions:
 instruction that does nothing
 instruction whose behavior is undefined
 instruction that has some probability of doing something completely random
 instruction that has some probability of going into infinite loop
 instruction that does always the same on one machine, but its behavior varies between machines
 instruction that under some (undefined) conditions can hang up the system
 instruction that has the ability to erase hard disk if misused
 instruction that can blow up the computer
 instruction whose use is discouraged
 instruction whose use is forbidden 
 instruction that is by its very definition obsolete
 instruction that will be removed in next release
:Among others, there will be some instructions that actually do something useful, though their good effects will not be documented. Programming would require avoiding "traps", both included in specification and not.
** I believe Vague has fulfilled this. 
** Isn't there already a language like that called "C"?
** It doesn't use those specific instructions, but there is already Undefined, but I created Undefined behavior (language) for you.
* an esolang that's somehow a superset of all the other esolangs
** and an esolang that yields paradoxes when trying to invent an esolang being superset of all other esolangs
** that'd be awesome because then User:Olsner get the benefit of having thought it without having to actually do any work
*A programming language based off of Final Fantasy, I.e. you have to code 200 lines before the program STARTS to have meaning.
** Perhaps something taking the pre-code segments to a major extreme? I'm imagining something like this COBOL program for IBM 360: 
*A programming language based on edible hats.
*A programming language that changes every time you run a program.
**Snowflake does this, although that's not a joke language.
*A language that looks exactly like C, behaves like C but actually is not C.
**Doesn't necessarily have to be a joke. One of the minor design goals of Feather is "code looks like Smalltalk, and often does the same thing but for entirely different reasons".
** GL Shader language.
*Language which uses Finnish grammar. Whole grammar with all word bending stuff.
** Using suffixes would be very, very esoteric. (from random -> randomista, object in list -> object listassa, etc.)
*Language based on the penis game. The syntax would be essentially be binary machine-level-esque code, the first bit would either be penis (0) or penis! (1). For each new bit in the program extra exclamation marks are added, if the next bit is a 0, one exclamation mark is added, and if the next bit is a 1, two exclamation marks are added. For example, 1000101 would be: penis! penis!! penis!!! penis!!!! penis!!!!!! penis!!!!!!! penis!!!!!!!!!
*Language with german parts of speech:
öffentlich statisch hauptmethode(Schnur[] argumente) ist
 ganz i; 
 solange(i kleiner 10) mach 
 buhl istFlach = i % 2 == 0
 falls(istFlach) mach
 println("Is flach, alter")
 ja wat denn
 println("Nich so flach :(")
 versuche das
 ...
 menno
 println("Fehler");
 so'n müll
 oder so
 aber schnell
gecheckt?
** Worse yet, this one's not even esoteric: http://reganmian.net/blog/2008/11/21/chinese-python-translating-a-programming-language/
* A language for SIMD computations with 128-bit vectors, with an endorsement written in the style of Gene Ray's . The endorsement tells you that computers can do "4 simultaneous 24 bit multiplications that occur within a single instruction", but that traditional programming languages have been trying to hide this from programmers so you can only operate on individual floating-point numbers, and the "K&R Bible Is A Lie".
*A programming language for computer to tell human what to do and how behave, that would compile from machine code to human readable code with optimization.
*A language filled with syntactic sugar to the point, you have to read the manual for every line to understand what the program does, kinda like assembly but higher level.
* A language that is designed to be unreadable.
** (()), unlambda, whitespace
* A language where the standard library consists of the viruses on the user's computer
** First, programs have to look for all viruses available and mix their code together to get the actual program out of it
** Then the resulting code is executed
** The file format would be some file format that antiviruses check for, like exe so the program can be constructed to look like a virus and therefore be able to include it's own code in the result, eliminating the need for true viruses to make it work
* An object-oriented language, where every class has to have 2 parents.
** There will be special tokens 'mom' and 'dad' to access them.
* A programming language that is capable of creating physical objects in the real world by importing .3dobj files. The .3dobj files do not represent 3d models or computer graphics, but actual, physical objects. The syntax might be something like this:
funct main() {
 import http://example.com/blue_cylinder.3dobj as cyl
 create object cyl in center of output
}
** Objects
* [cont. of above] The only catch is that it is impossible to write .3dobj files. Cortex (talk) 01:48, 13 January 2019 (UTC)
* A programming language that needs a lot of code that uses sophisticated concepts, you have to learn a lot of syntax to just print a "Hello, world".
* A language whose syntax is *dancing*
** Sorry, the above sentence sounds ambiguous.
* A language that uses only smileys { :), :P, :/, etc... } as valid tokens.
** I made a programming language that only uses smileys ~~
* A tape-based language that randomly rips and produces concurrent code. Perhaps it can even "stick" to itself or get "jammed".
** Broken Tape will probably satisfy you
* A language- wait, I won't tell you that idea, it's an idea for my pixeLang programming language!
** guess we'll never know what the idea was
** a language called "tell me the idea" user:tommyaweosme 14:46, 23 December 2024 (UTC)
* A language in which everything except plain text ("plain text" means things such as "Hello World" in print("Hello World")) is replaced by a different character, and you need a big table of symbols to program on that language. Maybe you don't understand what I mean, so here's an example:
 if input() == 'hi':
 print('hello')
 from time import sleep
 sleep(1)
 print()
 print('hello again')
^this is replaced by this v
 w l0o7|b::b e s:hi:s|t
 l0o6|b:|s:hello:s|:b
 f l21o0 i l21o63
 l21o63|b:1:b
 l0o6|b::b
 l0o6|b:|s:hello again:s|:b
or something like that.
* Some sort of language where every command is the name of another esoteric programming language.
** (WHATEVER WE NAME IT) would be ending the program possibly.
* A language that modifies its details based on what OS your using.
** I think probably most non-esoteric PLs are like that
* A language that only has one command: StackOverflow();. It does exactly what you think it would do, open a stack overflow page on your web browser. This is every programmer’s dream.
* A language where you have to type EVERY single outcome based on the value of the variables.
** Wait a minute, that is against actual programming rules and is thus ironic! Whatevs.
*** Wait, did I just say--
**** The entire universe is under arrest. You have the right to remain silent.
***** Oh no! We're going to die! We're going to--
 Huh? Where am I?
 You are in a place I call "nowhere".
 What do you mean?
 Your alternate self destroyed the universe, making everywhere, well, nowhere. 
 How do I fix this?
 Good question. Go to the part where 'whatevs' is said and delete that line, and the ones that come after.
 But this will crush our conversation!
 I know. But it is the only thing we can do. So go!
 Fine. Bye, I guess.
*A language where a sentences from this guy are code names
**Postrado
== Partially Silly Ideas ==
* Uncountable data types, inspired by uncountable nouns in at least one language. You can have one integer, two floats, three strings, four booleans and five dates, but you can’t calculate the length of a list of an uncountable data type.
For example:
 uncountable class Foo() {
 //any code goes here
 }
 
 Array[Foo] A = [Foo()]
 println(length(A))
will raise an error something like this:
 Error in sampleprogram.extension:
 > println(length(A)
 TypeError: array of uncountable data type has no length
** Here you go. ~Ω₁
* One where you have to play pong to input commands
* A tape based language where working with data reqires "cutting" and "folding" the tapes like a protein or genome.
**Ribosome
* A multithreaded language whose syntax is so simlpe, that you have to be very careful as to not accidentally create a fork bomb.
**Ψ
* There are languages easy to work with (most non-esoteric languages). There are also languages hard to work with (like Malbolge). The problem with hard languages is that when they are too hard, users won't program in them or worse employ some cryptoanalysis-based approach to break them and successfully write a program. So, the idea:
** a language hard enough so no usable program can be created with it in reasonable time;
** a language easy enough to lure programmers into writing programs in it, discourage cryptoanalysis and systematic approach.
** The goal is to maximize wasted programming hours before the user gives up.
** Programming in this language must be impossible, but the user has to have illusion that it is possible (if not easy).
** The language will have cool logo, will be advertised on boards and in press to attract as much programmers as possible.
** 6969 Assembler
* A programming language that must be run with paper and pencil, possibly similar to the CARDIAC Paper Computer.
* ’Pataprogramming (yes, the apostrophe is canonical), which is what lies beyond metaprogramming, i.e. meta-metaprogramming. The name comes from ’pataphysics, a parody of metaphysics. Many esolangs probably use ’pataprogramming already, but don't call it that. (CLC-INTERCAL's “compiler compiler compiler compiler” comes to mind).
* Peyo
* Preposterous Programming
* Rapture
* Silly Emplosions
* A tape-based language, where the tape can be unrolled, cut, stick to itself, be stuck to other things, scribbled on, pulled off, and thrown away.
** It may not be fully compliant, TAPASM
** Nice idea! DukkTap
* TIB and STIB
* The four loop, a loop that always executes four times
* In the spirit of Shakespeare, a language based on the outcome of jokes.
** Allocation with "There was this guy..." ("or A Rabbi A Cowboy and a ...")
** Positive, negative, neutral
** "and then" for adds
** control flow with Why did the chicken cross the road or some such
** Knock knocks for event loop control
* A programming language that takes MS Word document as an input where text formating plays role in semantics.
** Maybe expressions would be given by writing formulas?
* A programming language where after parsing, the parse tree is height-balanced and then semantics are taken (by interpreter or compiler).
* A programming language where you can only get EVERY variable's value fused together in order of assignment
** For Example, if I assigned the value of "Hello " to X and "World!" to Y and tried to call a variable, you would get "Hello World!".
** If there are ONLY integers, only then would you get an integer.
** Booleans do not exist.
* A programming language which does not support variables to store even integers or floats.
** Or one whose possible variable values are all defined in source code, and no other values than those can be used.
*** Basically a turing machine.
* A language where plus, minus, multiply and things alike (not even the "increase by one" or successor) are not primitives, but Lambert W function is a primitive. Programmer has to figure out a way to express the four fundamental operations by combination of BesselJ, LambertW (monads), Beta function (diads), and so on. The same goes for string manipulation and others. To make things simpler, for string, a primitive may be rot-13 encryption.
* A language inspired by how Bitcoin mining works (a good name for it would be Bitcode)
** For every line, the operation done is determined by the amount of change in the number of 0s at the beginning of the sha256 hash of the previous hash + the current line compared to the amount of 0s at the beginning of the previous hash
** The previous hash for the first line is the hash of an empty string
** There would be different operations for increase and decrease in amount of 0s
** There would be a no-op for every direction
* A language inspired by a randomly-picked file on a computer, which can be modified to fix into a new syntax. Powder is an example of this.
* “In order to put an end to the confusion between languages that put source first and those that put destination first, as a compromise, I suggest we develop a language that places sourcE first for Even lines of code and Destination first for odD lines of code. Simple!” idea (on Twitter) by David Madore
* A language where each instruction jumps a certain number of instructions, but you can only go backwards by going to the beginning of the code.
* A language where the source code is the same every time and you must write the compiler (or interpreter). No other data can be used to generate the program.
*A language where you use road sign names as codes
**⊗
* A language that uses a PNG's chunks, possibly using private chunks that only exist for the purpose of the language.
** A similar idea can be done with Application Extensions of GIFs.
* A 2d language in a non-monospaced font, so each symbol has a different length.
* A language where the source code is a puzzle that the computer have to solve first. The solution would become the instructions the computer will take.
== Looks Like ==
Ideas that look like something other than a programming language.
* A language written using ASCII art.
**Starstuff was designed to interpret ASCII art as runnable code.
** In Pyramid Scheme you write your code in ASCII art pyramids
* A language whose source code is a set of pre-made images put together into an image file. An interesting take on this would be making a language with the alphabet used in Codex Seraphinianus. It would be an alien programming language from bizarro world.
** That would be Piet, but the pictures are just block colours. PlaceReporter99 (talk) 10:07, 29 August 2023 (UTC)
***no its not. it could be but is also could not Yayimhere (talk) 19.12, 29 april 2024 (UTC)
* A programming language with Egyptian hieroglyphics.
* A language that looks like Geek Code.
* A language based on geocaching. The program could take place on the surface of a sphere. Addresses of instructions and data would be referred to as coordinates on the sphere. A new variable could be introduced by saying "<cacher> has 129 finds". "DNF", "find" "mystery", "multi", "regular", etc. would be reserved words. Cachers could meet each other, navigate on the sphere, hide new caches, log caches as found or not found, and caches could be muggled. For extra excitement, add travel bugs and geocoins.
* Menu.
* A language whose source code, input, and output are in PNG format, with an optional debug output that is text format.
* PokéArena
* A language designed in such a way that source code looked like poetry or song lyrics.
** Beatnik is somewhat appropriate for this, but code usually makes no sense in terms of a song/reasonable poetry. Perhaps a "positive word" (happy) is worth one, a "negative word" (sadness) is worth -1, and adjectives multiply by two (like in shakespeare programming language), with the value of a line adding up to a value (all nouns (nouns consist of nouns themselves with joined adjectives) summed together), which executes like beatnik values. Unfortunately, this language is not Turing-complete.
** Esketit has a code that looks like Lil Pump’s song “Esketit”.
** Poetic. You're talking about Poetic.
* A language based on Rick Roll, where every line in the song does an action that is relevant to the line, such as "Never gonna give you up" protecting a line so that it can't be modified, only read, etc.
** Alternatively, a version of BF where all the commands are lines from Never Gonna Give You Up.
* In Soviet Russia, esoteric programming language invents YOU!!! - Idea turned into SovietCode
** Hello World program would look like this:
 In Soviet Russia,
 "Hello World!" prints YOU!!!
:And Fibonacci numbers could be like this:
 In Soviet Russia,
 times inputs YOU!!! # receives input and stores in times variable
 1 in x stores YOU!!! # sets x and y to 1
 1 in y stores YOU!!!
 Does YOU!!! # the looping struct
 x prints YOU!!! # we print out x
 x and y adds YOU!!! # adds together x and y - is temporarily stored in YOU!!!
 y in x stores YOU!!! # stores value of y in x
 YOU!!! in y stores YOU!!! # stores value of YOU!!! in y
 While x and times compares YOU!!! # while x < times
 # other comparisons: x and times equals YOU!!! (x == times), x and not times equals YOU!!! (x != times), x and maybe times compares YOU!!! (x <= times)
** Maybe combine this with the 'Soviet Script' idea from the Jokes/Silly Ideas section. Something functional would look like:
 In Soviet <modulename>, # declare module
 <modulename> imports YOU!!! # import/include/open/use/... a module
 # or just don't include modules in the language, because there should be only One True Module?
 
 x, y, z in <fnname> take YOU!!! # declare a function with arguments 'x', 'y' and 'z'
 ((x and y add YOU!!!) and z multiply YOU!!!) returns YOU!!! # return (x + y) * z
 
 n in patternmatchingexample takes YOU!!!
 # match n with
 # | 1 -> "one"
 # | _ -> "not one"
 n matches YOU!!!
 n and 1 equal YOU!!!
 "one" returns YOU!!!
 not n equals YOU!!! # or something else?
 "not one" returns YOU!!!
:Every object is dynamic (so the One True Type is useful for everything), and it should implicitly catch all exceptions.
* A programming language with the most easter eggs, by specification. Perhaps the Ada 95 spec, tweaked, GNAT tweaked to suit. Jada, the jaded Ada
* A programming language that looks like an order at a restaurant. Drive-In Window
* A programming language that is comprised entirely of Duke Nukem quotes.
* A language where flow control, assignment, calculation and basically everything is done using unicode arrows
** Different kinds of arrows would do different things like simple arrows do assignments, unconditional control flow, dashed arrows conditional control flow and such
* A language that looks like a golf ball lost in parentheses.
** Maybe IncLoop would be like that if I had remembered this when creating it and used o instead of . (example: ooo(((o))) 
* A language that looks like choreography.
** This may be really complicated. It may be based on a 2D map where each cell has a value, like Befunge. Or you may mean to say "Choreography notation".
** A suggested name for this language was "Balletic".
* A language similar to Shakespeare, but is intended for steganography.
* A language that looks like an ordinary crossword entry.
* A language where two squares are in two corners of a field and if they colidr with eachother. The program ends
** ⿻
* a language that looks like 3 board games at once
* a language that looks like a robot/spaceship
== Derivative Ideas ==
Ideas based on other languages.
*BCDFuck: A brainfuck variant where the input is in BCD, except that the unused six states of 4-bit BCD encoding are interpreted as brainfuck-like instructions while 0-9 are stored directly in the cells as they are entered.
* A BitBitJump variant using variable-length addresses. For example, each address bit except the last one could be succeeded by a 1, while the last address bit would be succeded by a 0 as an end marker. This means that addresses can be arbitrarily large, possibly making BBJ Turing complete.
* Black and white and read all over
* After each cycle the whole tape of a brainfuck program gets reversed and encrypted (XOR) with the number of cycles the program ran mod 256.
* We have COBOL (COmmon Business-Oriented Language), so why not:
:COSOL - COmmon Science-Oriented Language (like Fortran/C).
:: COSOL - The COmmon Stack-Oriented Language (which I made)
:COFOL - COmmon Function-Oriented Language (like ML/Haskell).
:COOOL - COmmon Object-Oriented Language (like Java/SmallTalk). This could just be called "COOL."
:: COBOL, no not that one, the Card Oriented language, implemented in COBOL, yeah that one.
* The program goes through the C preprocessor, and then after unquoting strings (and possibly doing a small number of other things too), it runs it though the C preprocessor again, and then repeats it over and over again...
* A language whose programs when executed must output a program in another language, which when executed must output a program in another language, etc. Think how cool would a Befunge -> Brainfuck -> Python -> Java -> INTERCAL -> Whitespace -> HQ9+ program would be.
* Eitherf*ck
* Argh! But all of the programs are like they were from AsciiDots
** For example, l (lowercase L) would be > in such a program.
** Example 2: k would be ^
* Combine 2-dimensional fungeoid with an array, verb-stacking paradigm similar to J/APL.
* INTERCAL in a language other than English.
** It's been done, it's called INTERCAL. (More seriously: C-INTERCAL accepts the program being written in Latin instead. Not that anyone's tested it for years.)
** CLC-INTERCAL also allows you to redefine the syntax to whatever you want (including at runtime)
* Take C++, but remove everything except the bare minimum required for turing-complete template meta-programming. The keywords template, typedef, typename and struct should be enough. Could get rid of either struct or typename with some trivial changes from C++, but if you want to keep it compatible your options are more limited. (See Ser2 for an attempt.)
** Using can be more useful than typedef as using templates are possible. Enum might be useful too but not necessary.
** Nestplate
*New naming schemes for variables in ordinary programming languages, and automated ways to add and attach those new kind of names to existing variables. New name could be separated by some character or string from the old name like this: oldname_newname, so that different naming systems can coexist in one source code. New or better variable naming schemes could be (especially?) useful with disassemblers that convert compiled programs to, for example, c++.
*Ways to interpret normal languages that somehow take into account the names of variables.
*String rewriting system that changes a source code in normal language, and possibly is affected by variable names.
*Compression format to compress some subset of harmless programs in, for example, c++ to a tight string like Gjvghqh4Hvnas... Would have use at least in resource hungry video and other codecs, and in arrangements where something is sent to other people's computers to get computed, where java would waste resources to some degree. 2 modes, variable name encoding and variable name losing by numbering. Because the compression format could not express anything harmfull, and also possibly only part of the set of all possible harmless programs, it would be inherently safe and tighter.
**In addition to being unable to represent harmful programs, make it be unable to represent redundant things such as a=2; a=3; and so on.
***Rice's theorem would like a word with you.
****Tell Rice's theorem I'll return its call when C++ is Turing-complete. If I want my computer to spend the next spagillion years enumerating all possible states of its memory, that's my business!
****Things such as a=2; a=3; are not all redundant things, only some of them. So, I should think that Rice's theorem won't stop it from removing that. (Anyways, this specific example, I think an optimizer can easily remove it anyways, and it can be detected easily enough.)
****:(
*Programming for a simulation of big group of very small computing nodes that work similarly to BOINC, but also with nodes that move on a 2D plane and have peer to peer communication also.
**Integrating BOINC like computation to a TOR-like network, whatever that means, with or without the encryptions etc.. Almost completely peer to peer way is the main thing. This is at least now a very vague idea.
*Program that automatically converts source code in some normal or esoteric language to a patchwork or network of small symbolic pictures / pictograms / ideograms. The symbols would be interlocking in such way that all compatible ones, i.e. functions and types that can be adjacent and dependent on each other in a normal source code, would have some continuous lines and colors from symbol to the next. If a function or variable does not have a picture, it's name is just put on a square or rectangle in 3*3 character formation. Words or constants would have first 9 letters or digits shown. 
**Constants could also be represented in binary form, with black and white pixels in a string representing it's 1s and 0s. If the square showing the first 9 decimal digits is over 64 pixels wide, the binary string can be on the upper edge if the number is any normal length.
**Some pictures are default that come with a language, others can be supplied with source code for custom functions, classes and variables.,. Most default pictures can be used with all languages, whether normal or esoteric. 
**Especially variables could be just properly cropped and scaled images taken with a digital camera. If a variable is meant to count apples, it is represented by a picture of apple next to a symbol meaning a type of number. Picture could be a datafile that the software is meant to use in its user interface. If there is nothing better, arbitrary default pictures of objects can be randomly assigned to some variables. 
**Some pictures would have subtle symbolical meanings. Sunset could mean return output and exit function, or exit program... 
**See also:Emoticon
*Programming that uses sifteo cubes for interface and display. It may be derivative and implement some existing language on them, or it could be a new language made to take advantage of sifteo cubes. wikipedia:Sifteo_cubes
*Object oriented thue, I have created the page for this now but don't know what to do with the posts below this.
**Just go to This_is_the_name_of_your_Thue_derivative and click the edit this page link.
***To clarify: to create a page, edit a link to it onto another page (for instance, the language list), then click on the link you just added.
****You don't have to edit a link, you can just search for the page.
**How about event-driven Thue? For instance allow meta rules of the form "If you just applied substitution rule X, then immediately apply substitution rule Y."
**:o
*Multi-threaded Befunge.
*A language that has the same syntax as some existing language but its semantics is completely different (+ means -, int means float, the program is executed backwards etc.)
**Cappuccino is this for Java.
**ScriptJava is similar for JavaScript.
*An esolang that is a derivative of itself (ideally in a way that makes it possible to deduce most of its semantics via induction, despite the lack of a base case).
* (((()))) or full nest
** a (()) or empty nest derivative
** it's interpreted in a loop
** for first iteration, the code is the program's code
** for other iterations, the code is the result of the previous iteration
** the looping ends when the code contains only data and only one body - example: ((something))
** when this happens, the output is constructed based on the following rules
** (()) is turned into char code 0, (()()) is turned into char code 1, ...
** everything not matched by the rule above is executed as another (((()))) program and it's result is pasted - example: ((something))
** programs without any data, matches and not the original code - the only possible is () - results in an empty string
** programs can have multiple bodies, their results are merged - (((((()())))))(((((()()()))))) - results in a string containing char code 1 and a char code 2
** the code's first body has no data, it's read from input - example: ((((()))((()())))) replaces any char code 0 with char code 1 in input
** the input is transformed similarly to how output is transformed, but opposite way, char code 0 is turned into (()), char code 1 is turned into (()()), ... and is enclosed in (())
** to delay getting input to another body, use (((data))) as last in a previous body - example: ((((((a))))))((((()))((()()))))((((((b)))))) replaces any char code 0 with char code 1 in input, appends a at the beginning and b at the end
** |( and |) would be to escape parentheses without a pair and || to escape |
** everything other than |, ( or ) is ignored
*HTML+CSS+JS but you need to vendor prefix E V E R Y T H I N G with -pain- or sth. Imagine right <painscript>painDocument.painGetElementById("some_button").painAddEventListener("painclick",painAlert.painBind(null,"hello world"));</painscript>
* Variant of Poetic that uses Chinese (already exists) characters or Korean characters instead of English words
* C++ or brainfuck, but each character is expanded to a considerably much longer & more meaningful name. e.g.#include<iostream> = include_files_in_header(header_name(input_output_header_streamlike))
** and, int main(){cout<<"Hello, World!";int i=10;while(i--)cout<<endl<<-i;} equals function_define(main,type_name_specifier integer_type_4_bytes)arglist_start arglist_end codeblock_start stream_insert(output_stream_to_standard_output,string_constant("Hello, World!")) end_of_statement variable_define(variable(i),type_name_specifier integer_type_4_bytes) variable_assign(10) end_of_statement while_loop(decrement(variable_value(i))) codeblock_start stream_endline(output_stream_to_standard_output) end_of_statement stream_insert(output_stream_to_standard_output,negate_sign(variable_value(i))) end_of_statement codeblock_end codeblock_end. MUCH fucker than brainfuck!
== Music ==
* Ones with music (like Choon or Fugue), but using Bohlen-Pierce scales.
* Combine the ideas behind Choon and Fugue into a single language where the programs are music and the output is music, then compose a piece called "Eine kleine Quinemusik".
* A language that uses a sound file and the properties of sound as code.
* A programming language which takes a "guitar tablature text file" as the input. Each string is a function (like "put in the stack", "print as ASCII", etc.) and the number on the string is the number which will be involved in the function, so source code can be played on guitar.
* A programming language that uses songs as input, and programs have to be at least somewhat pleasant to compile. A simple way would be to base it on harmonics, so if you play two notes at the same time that aren't harmonic, it will be invalid, but it would be better if chord progression could be implemented too. Also, I think music is supposed to have short periods of dissonance between harmony.
**That would require some AI for interpreting.
* A language in which every valid piece of music (or maybe just for only piano, only violin, only voice, etc) compiles and runs without error (and does something). It would be more interesting if simpler (beginner) pieces were simpler programs, and more complex pieces (such as Rachmaninov) were more complex programs.
* A program in which every line from Daft Punk's Technologic is a command.
* A two dimensional musical esolang that is a hybrid between Piet and Fugue. The dimentions (lines) are separated by bars （or maybe tracks instead）. Not to be confused with Befunge. The loudness of the notes may also matter.
* A language that uses wave files as source codes (.wav). It is intended for steganography.
== Mathematics ==
* WAKE: A language based on (a) the classy decommissioning of data (give it a wake if you want to honor it!); (b) detecting and creating bias in data; (c) measuring distinctions between data; and (d) granting and revoking privileges on data. This implies that variables are inherently complex, containing values, but also carrying a bias and a privilege level. How does this privilege level affect data in flow through the program? I think decommissioned data has the lowest privilege --- or perhaps it has the highest? And how does bias work? Does it merely apply a weight to contained values? That alone might make it useful for neural network modeling but are there more subtle uses as well?
* A language based on a different number system or an imaginary number system
* Set Language
** Would it be possible to have a programming language in which programs are sets, and every possible set is a valid program?
*** Yes, see Π₁. Every function is a set and every set can be called as a function (and the entire program is also a function). However, calling a set that is not a subset of a cartesian product is implementation dependent.
*** Could LISP be considered a type of "set language"?
* Hyper Set Language
* Fractran with complex numbers. (See on Good Math, Bad Math article.)
** No. The Surcomplexes (of the form {L0|R0}+{L1|R1}i, where (L|R)(0|1) is a surreal (or surcomplex?) number). THAT'll get them.
* A functional language based on the rho-calculus instead of the lambda calculus.
* Programming language where all computations are done due to something being disproved.
* A programming language that takes a mathematical expression, and the interpreter try to simplify it, and during the simplification, it will encounter side effects. The order of simplification will affect the order of side effects. For example, `2(x[IF_PREV(<*>, 2) { print("Hello") }] + y[WHEN_DEPTH(0) print(" World")])`, and the expansion, `2 x[IF_PREV(<*>, 2) { print("Hello") }] + 2 y[WHEN_DEPTH(0) print(" World")]` will print "Hello World". The side effects can be more complex and manipulate the expression tree itself.
* A multidimensional language, where the program is a set of points in Rn and a function which maps these points onto Rm; this process then repeats with the new program and a new function on Rm. Maybe it could be called something like Projection or Linear Map, although these may be too normal/restrictive, in which case Morphism might work.
* A programming language based on hilbert's tenth problem: the program is a diophantine equation, and the computer is searching an integer solution to the equation. It would probably be turing-complete by Matiyasevich theorem.
** I'm reasonably sure that at least one famous-ish mathematician has written a Lisp interpreter in this. So it would be TC.
*** It was Chaitin.
* A language whose type system and execution is based on some non-classical logic.
** A type system of any of today language has strong relationship to logic. Existence of an instance of some type is equivalent to truth value "true". Non-existence (i.e. of some void type) is equivalent to "false". The new language may exploit some non-classical logic for its type system.
*** I.e. fuzzy logic would yield "partial existence" of some type instance and "partial correctness" or "partial error" of its type-check.
*** Modal logic would effectively give us more specific type properties. I.e. "type correct for programs shorter than X", "type correct only for standard-library usage", "type correct unless type Y is also used" and so on.
*** General quantifiers in type systems give us parametric polymorphism (like C++ templates). Existential quantifiers give us abstract types (like Java interfaces or C++ pure virtual classes). If we introduce the uniqueness quantifier ("there exists exactly one"), this will give us automatic singleton types.
** From computer science we know: A specification of a program is a logical thesis. The program source code is a proof of its specification. Standard library is the axiom set. "for-each" loops are general quantifiers. Local variables are existential quantifiers. Program compilation is mathematical model generation. And so on. We can replace any of the classical logic concept with an exotic one. Some non-standard quantifiers? Unusual proof methods? There you go.
*** The mathematical concept of normal model means eager expression evaluation, like in standard C. The concept of Herbrand model gives us lazy evaluation.
*** The "exec" statement present in some languages is essentialy the "neccessity" modal operator from S4 logic system.
*** Compound statements are related to logical conjunction in proof theory. Logical alternative translates to exceptions and transactions.
** Types in Haskell and so on are intuitionistic logic. With continuations you have classical logic. There are many other kinds, so you can have linear logic, noncommutative logic, temporal logic, and various others; I don't know exactly the meaning of such type systems but maybe it means something.
***I think linear logic has been investigated for this before, it gives types that keep track of resource usage, I think I saw mention of a paper about using it to replace (some) garbage collection. Clean is similar to Haskell but has "uniqueness" types which I think are based on something resembling, but not quite equal to linear logic. Someone investigated temporal logic and found it gave types for functional reactive programming which is important for doing GUI stuff in languages like Haskell. On the very primitive side, I found something called "basic logic" on the net, which looked to me like it could give types at least to a continuation-based language. It has both linear logic and quantum logic as supersets, and I tried seeing if I could get something corresponding to the latter, but I couldn't see any intuitive meaning to the essential orthomodular law...
****I remember reading (I think it was in Benjamin C Pierce's "Advanced Topics in Types and Programming Languages") that affine types are a natural corollary of linear types, but that no practical use for them has been found. So these might be a candidate. But wikipedia's article on linear types make them sound boring, so maybe not.
***I have to wonder what a basis in Abstract Stone Duality would do to your type system.
**Base something besides the type system of the language on one of these logics. Particularly, pick something for which it is difficult to imagine how to base it on a logic. Possible examples: macros, updatable stores, the rules for throwing/catching exceptions.
** A logic-based language which is based on infinite unification. In other words, turn the occurs check on its head: insist that variable V can only unify with terms that do contain V. (The wikipedia article has a reference to a description of the semantics that comes from allowing infinite unification, but I'm not sure what the consequences of requiring it are.)
* A language based on knot theory or braid theory
* Define "two's compliment" arithmetic ("I like your LSB"; "This old thing? Oh, it's nothing, compared to your MSB", etc, etc) and add support for it to the esolang of your choice. (Inspired by a typo on one of these wiki pages that was fixed a few days ago)
* An implementable version of SNDL (preferably with I/O, too.)
* A visual programming language in which a self-interpreter is a "proof without words" that it is indeed a self-interpreter: its code is unmistakably visually similar to the code interpreting it.
* A language where the line numbers are ordinals (finite and infinite), rather than only natural numbers.
** Furthermore, a language where the line numbers are surreal numbers. Or, where the line numbers are surcomplex numbers.
* Programming language based on category other than a category of functions (maybe one where the types form a category?), and having monads on that category.
* Something based on sequent calculus, where rules can have side-effects including to allow the program make up new rules and delete or alter existing rules.
** Gentzen uses sequent calculus, but does not allow for self-modifying code.
* The classic textbook Aho, Ullman, The Theory of Parsing, Translation, and Compiling, (1972), explains in chapter 2.46 that there exist such context-free languages that have no unambiguous context-free grammars, and that such languages are called inherently ambiguous. After that, it states that “no inherently ambiguous programming languages have been devised yet”. This sounds like a challenge to find a programming language that is like that, or, failing that, create one.
* Language based on non-euclidian geometry and mind-twisting functioning compared to understanding things in everyday ways.
* Language that is both insufficient to be turing complete and uncomputable at same time. It is possible with making the program able to define Pi^0_1 set but not Sigma^0_1 set (i.e. Recursive Enumerable set)
* Language that the halting problem is decidable for using a Turing machine while being uncomputable
** A program in it must be able to run into an infinite loop, including conditionally running into one
* Base X numbers as the only numerical type, where X is either a prime, a non-integer or complex number.
** Let X = 2 (prime number) and you have an ordinary logical circuit.
* A programming language based on Gödel numbering, so that a program is simply a massive number which encodes the actual program.
** Brainfoctal
** Factor
** Bitwise Cyclic Tag
* A language where you can only store any data by finding it in the digits of an irrational number
** One would have to manipulate the data only by manipulating the irrational number or the number of digits used to represent the data
** When the irrational number somehow becomes rational after a manipulation, the program halts and prints the number to the output
* A language in which all numbers are stored in a prime factorisation representation, eg. decimal 4802 becomes [4001] (7^4*5^0*3^0*2^1). All operations have to be defined as factor operations on these numbers, such as incrementing and decrementing factor powers (multiplication and division), shifting factors left or right etc.
* A language that makes use of the mortal matrix problem, either by using matrix multiplication to make the language's own behaviour undecidable, or by including an oracle for the problem as an undecidable element.
* A language that has a hierarchy like Banana Scheme, but starting with lang_0 is a language that allows exactly the definition of all primitive recursive functions, and then lang_n+1 is lang_n with an interpreter function for lang_n, ex: retval interpret_n(godelnum/encoding for lang_n). The language would be the union of all lang_n for finite natural numbers n and would be total.
* An interactive theorem prover in which, unlike traditional systems where statements are types and proofs are programs, statements are programs and proofs take the form of optimization suggestions. In this framework, inference is expressed through reduction, with each provable statement ultimately reducing to True after a finite number of reduction steps. However, the application of reduction rules can occur in various ways, leading to exponential time complexity. When a proof is provided, it guides the reduction process, allowing the statement to reduce to True more efficiently.
== Physics ==
* What about a language based on ballistics? You could have an "artillery piece", whose commands are the source code. It can rotate and elevate, and have muzzle velocity specified. It fires at a 2D grid placed in a square around it. The grid elements are the memory locations, and the angle of impact specifies what to do. This would likely need a lot of computation, though.
* A programming language that is modeled after an infinite space full of gravitational bodies (though there can be other forces) that are arranged in a pattern. A projectile will be shot from (0, 0), and getting close to the different bodies will perform different instructions. The program is a only pair of full-precision floating point numbers, of the x and y coordinates of the initial velocity. If the numbers have infinite digits, instead write a function that returns the nth digit on-demand. The construction of the placements of the bodies and the method to find the initial velocity will start some long research.
**Is Gravity this? (Except uncomputable.)
* Physics of planets/astronomy tells the program what to do (possibly by using astrological signs or aspects or whatever). Possibly make such an esolang feature usable with User:Zzo38/Astro-Q
** It could be kind of similar to Wait; the current positions of the planets are used (which can be computed if the current time is known).
* A programming language based on some game such as cricket, or football, or whatever game.
* A language based more on a model of reality than physics per se. This idea may be applied in some MMORPG game or a virtual world simulation ("Matrix"). The core concept is to be able to construct an "item" without programming, just putting some parts into it. I.e. when you want to construct a clock, you put some wheels into a box - and you have a clock. To change its behaviour, i.e. to get a clock moving backwards, you replace some wheel with some other one. No "coding" in any textual programming language, just arranging items in a certain way. The closest relation of this system is agent programming.
** They call this Minecraft.
** The basic type is an object. There are basic objects (atoms) and compound objects that are composed of other objects.
** Each object has identity, i.e. there are no anonymous objects.
** Objects generate events and accept manipulations via methods. There are methods common for all objects.
** There are methods for inserting an object into a collection and removing them from a collection.
** There is a synchronous global clock. All objects change state in massive parallel style. At each iteration an object generates a proper event and may be called a method.
** Compound objects listen to their child objects' events and manipulate them using methods, basically binding events to methods.
** For any compound object, its behaviour is completely determined by its content. Bindings, generated events and accepted methods are defined by existence or nonexistence of some child object. That means, this language is homoiconic . An algorithm is a certain data structure.
** A user (programmer) is an object also. He can only program calling methods on objects accessible to him. A programmer may be restricted on what he can program i.e. by not giving him certain object types.
*Known laws of physics are expressable with equations, but what if there are yet unknown laws of physics that can be expressed only as programming languages? They presumably would be non-textual and pattern based, when arrangements and patterns of matter and energy (and possibly dark matter) are the program and data. What would it mean if a law of physics were turing complete? What kind of experiments would have any chance of finding such law? The law could be such that only valid patterns cause any effect, so no "error messages", and also such that it has memory in some form, like stack, deque, graph or something stranger... Yes, a law of physics that has memory seems to be a remote possibility. The valid patterns of matter and energy would be in unknown scale, possibly starting from atom scales and nanoscales...
**I think all programming languages are expressable with equations, and all laws of physics would be expressable with equations even if they may sometimes be uncomputable
**The known laws of physics also seem to be expressable as a cellular automata. But despite looking rather neat there's no extra testable predictions yet so it's a bit of a so what.
**Then the existing laws of physics appear to NOT be turing complete; if you try to do anything with infinity they will GET YOU! (Perhaps not at zettametre scales though) Rdebath (talk) 17:40, 27 July 2014 (UTC)
* A crystal processor but with quark matter.
* An esoteric physics simulator (esophys)
* There is a branch of optics dealing with holograms. It is possible to make a hologram that transforms incoming light in a specific way, i.e. increasing some frequencies and dampening others, or even amplifying some shapes while discriminating others. Now make a programming language for THAT.
== Computing components ==
* An assembler-like language that can be executed forwards and backwards. And when executed backwards, it undoes what it would do when executed forwards.
** See also: :Category:Reversible computing
* A language executed by trained rats.
** Or, the variant: It is executed by a secretary who is doing the job they are being paid to do but not knowing what is the significance and purpose of such the job?
* A programming language or additions to some ordinary programming language (like c++) that makes a computer work as if it has analog computing parts. Floating point numbers would have random noise effects in each copying, computation and with passage of time. Also in array, adjacent cells would affect value in amount proportional to storage time and in each copying in similar ways that analog copies of vhs-cassettes or c-casettes differ. This would work in c++ with some new data types. The amount of random effects or "temperature of the analog parts" should be adjustable. Each variable should also carry the original values and digitally computed values so that it is easier to track the increase in error. Category:Probabilistic
**Also, data types that can have different base than 2, and significant probability of "physical" error, so that the nature of random value changes depends on the base. 10 base number 6 could randomly change to 5 or 7 and with much lesser probability to 4 or 8, but never to 11 (eleven). Then the programmer has to try to achieve robustness or minimize errors despite of these difficulties. The program needs to store and compute same things 2 or more times, in a way that is unique to this kind of programming. I guess some tasks would be done most efficiently by algorithms that are somehow strange / different in surprising ways.
*Language in which use of some simulated "components" that barely work at all can not be avoided. The probability of correct answer from those "components" is only slightly higher than random, for example, (1) square root of probability decimal for random, so that 50% chance i.e. 2 options, i.e. 0.5 chance is 0,707106781, 5% chance i.e. 20 options i.e. 0.05 chance is 0,223606798 etc. Or (2) average of probability fraction for random and bigger fraction, like this ((1/2)+(1/1))/2, ((1/3)+(1/2))/2, ((1/4)+(1/3))/2, ... , ((1/20)+(1/19))/2 etc. Or some other calculation formula. Getting reliable results would need countless repetition. This language might be in the category: resource hungry, and if so, it's implementation could have a good reason to use OpenCL. The language or some programs in it could be made such a way that as a surprising consequence of it's design and properties, if the special "components" worked correctly i.e. with reliability of near 100%, the programs would give wrong results. If the "component" reliability gets closer and closer to randomness, at first, the program would work more and more reliably until some optimum, after which it starts to get less reliable unless it starts to work slower and slower. The working slower and slower property might in some versions of such language, also be automatic unplanned surprising consequence of the language's design. I don't know if there is one or more some kind of universal constant(s) involved here, that apply for all programs, or if it is always program-specific. More questions: (1)would the lowest quality pseudorandom number generators be enough for the implementation, or would it need very high quality randomness? (2) What if the component unreliability was somehow meaningfully biased to some type of wrong answers? What that could mean and what problems it could cause?
** Von Neumann did this in "Probabilistic logics and the synthesis of reliable organisms from unreliable components". Spoiler, if you don't mind exponential growth you can bound the overall error as low as you want. The paper's slightly difficult to find so here's a review by Shannon.
*A processor that is designed for running a cellular automata suitable for actual computation, would be terribly inefficient for most uses, but could it have one advantage over the more efficient but complex processors: it is more transparent in the security sense, i.e. it is easier to check that there are no tricks hidden in it. Such cellular automata processor would necessarily be an open source processor at least in some sense.
== Game ==
* Magic The Gathering card deck of programming language
* Chess
* A language based on a roguelike game such as NetHack. The language would be non-deterministic, since roguelikes are traditionally very random. "Programs" would be represented as a player - the interpreter would act as a bot going through the dungeon, functions would be learnable skills, and data would be treasure and junk found in the dungeon. Since permadeath is a feature of roguelikes, there is no guarantee that a program will succeed in executing, although if a program does succeed in execution, it would be guaranteed to produce an accurate result. To make things more difficult the program could only produce the appropriate result after successfully obtaining some artifact (e.g. The Executor) and leaving the dungeon.
** I like the idea. (I've been playing quite a few roguelikes lately.) Perhaps the code could be a layout of a dungeon and then an instructions list.
** An important feature of roguelikes is randomization, so I don't see the dungeon layout being "hardcoded" as part of the code of the program. Plus, having a randomized dungeon means that programs have a more varied opportunity to fail. Different dungeon features could be included or excluded in the code using libraries perhaps.
*** Instead of the dungeon being completely random, though, the programmer may be able to specify certain important features (e.g. a treasure on floor 3 containing data input from the keyboard). Of course, there's no guarantee that the compiler will pick up the data (especially if it is randomly placed behind a secret door).
** Hmm... I think the code should be divided into two sections, one for "Data Processing Code" (the code you are trying to run) and one for "Survival Code" (the code that controls the player). The Data Processing can only be affected by the dungeon by pausing until the player's status allows it to continue (e.g. Instruction not Learned) or dying. The Survival Code can receive all data that would normally be visible to the player, and use it to attempt to allow the Data Processing code to continue. Basically, every program must contain an artificial intelligence engine capable of playing the roguelike built into the interpreter reasonably well (or you can let the user do it) in order to function, with the goal of the game being to execute the code.
** Alternately, a language in which the code looks like a Nethack (or other Roguelike) level, inspired by the fact that a lot of the examples look like they're halfway there already.
* A Deadly Rooms of Death-based programming language. There is a room with walls, switches, one-way arrows, etc., some monsters that move in specified ways (in DROD, they would be roaches, roach queens, goblins, etc.), a target for the monsters' AIs, and the code is the room's layout and the position of the target at each point in the program.
* A language which is actually a list of instructions/keypresses which are input in a video-game (with a predefined random seed), and commands are executed depending on which enemies the player kills, the final score, etc.
* A language based on the Mahjong game.
** You could have a "mahjong operator" that, if you have a tenpai hand (where a complete hand must contain any number of sets of three tiles and up to one pair), the output will be the list of possible tiles to complete the hand.
** This could be combined with a concatenation operator and a condition operator, too.
* Esolang based on Pokemon card game. 
** There's Pokebattle, but it doesn't seem to be based on Pokemon card game. -- ColorfulGalaxy ( talk | contribs ) -- please sign your comments with ~~~~
*Language to define bots in multiplayer FPS games and similar 2D and 3D games, so that third party server administrators can use copies of them, in numbers defined by rules they set. Bots could be used to balance sides, so that the side with less players, will get enough bots to make the difference. Or if game is going badly, bots are added to the losing side. Or some other rule. The reaction times etc. of bots would be limited to some fair level by server settings, or bots could be limited for decoy and support roles. Bots could also be just for making vehicles autonomous. Server settings could allow players to use 1 own bot with a custom program. If the personal bot is running on server side, it's use of computing resources and turing completeness can be limited by server settings. Mandatory random mistakes can be forced by server, in which case the bot runs on a special mistake mode for 0.1-2 seconds on random intervals.
*A language based off of Final Fantasy. i.e. you have to write 200 lines of code before the code even STARTS to have meaning.
*A programming language designed for making chess puzzles or whatever that are provably correct if and only if the program typechecks.
* . Write code as if we are playing an RPG. The code looks something like a combat log of an RPG or AI script.
** Liked it: Laclale (talk) 16:04, 30 January 2022 (UTC)
*** Plurple is here!
* An assembly like language that is written inside a Minecraft world and run by a mod. All memory and instructions are blocks.
* An language based on the roulette game
* Tetris, a language where you put down commands in the form of blocks that get executed when a row is full
* Maybe BMS-like language?
* alright. hear me out. sudokode.
* A fungeoid with the box traversal mechanic of Patrick's Parabox.
== Implementation ==
* A Befunge interpreter named "v".
** If you used the interpreter named v in your path, then you could use a #!v line to start your program, thus making it runnable without typing in the name of the interpreter at all. (That is, your befunge code with the #!v as the first line would be executable.)
** Your program would end up starting in the third column going down, but having it be runnable from the command line would be cool.
*** Any name starting with v would work too, such as vefunge,
**** I would suggest something that can compute a line starting with #!/usr/bin/env. In Befunge 98, the cursor would be returned at the u, meaning that the executable name should end in a sequence that drops the last element of the stack and places the cursor to the beginning of the third line, or at least moves downwards. A good example for Befunge 98 would be the name 'j', which nops twice and hits the 'v' from 'env'.
* Write an operating system using one of the esolangs.
** Start here? 
** logOS doesn't count as an OS, does it?
* If more users are interested, we could create something like the esco project (which seems to be dead) on sourceforge, an interpreter for a lot of esoteric languages with more added over time.
*Implementations that use OpenCL for parallel computing speed.
*Current hardware has all sorts of features for conserving energy and reducing temperature, so that hardware does not use more than the software needs it to use. It seems plausible that the fastest program is not always the most energy efficient. Last time I checked, gcc compiler had not optimization option for minimizing the amount of joules / calories needed to execute a program ( but it has optimizations for speed and memory ). Should compilers for esoteric and normal languages have an energy optimization option? If a program knows the hardware like a system tool, can it be made to estimate how much it consumes energy? Can programs be made to print at termination the number of joules that they increased the energy use of the computer?
**I also would like to have such option in a C compiler and in a Verilog compiler. And maybe also INTERCAL.
* A brainfuck or C compiler that compiles into a DNA or other unusual computing system.
* I challenge writers of eso languages to write a version of the game "Tic-Tac-Toe". It seems far too easy to write a "Hello, World" program. "Tic-Tac-Toe" would only need a gameboard set up, a conditional loop of some sort, logic for the computer to figure out what the next move would be, an input statement, an output statement, and a determination if the game is a win or a draw. You wouldn't have to write the whole program either, just prove that it's entirely possible.
** A gameboard wouldn't be strictly necessary, as players could just use the numbers 1 to 9 to indicate a square.
** If you show that it's Turing Complete, you've already proven that a Tic-Tac-Toe program is entirely possible.
** Tic-Tac-Toe is actually very easy to implement if you let the computer go first, because it doesn't need any state at all to produce a program that never loses. In particular, you don't need flow control (e.g. it can be done using the floodfill of many image editors).
** Worse, some eso languages don't have input.
*Considering it's structure, an actual processor that natively runs Ante. You'd need four registers, a bus to retrieve code data from, output bus, and maybe a processor status register. I wanna see more Ante.
*A physical computing machine designed to be manually operated by crows such that the actual computation is perfomed mentally by the birds themselves.
== General Ideas ==
* Inflection
** Or taken to extreme: Polysynthetic language where almost everything can be expressed by altering variable names.
** I think that's already implemented in Espro
* Stalactite
* Primordial
* Two Fifty Six
* FRM
* Isolated
* Timesig
* Bool
* Esoteric Verilog
* Correct Syntax Error
* (potentially useful - is this esoteric enough?) A system where the program and the data are encrypted, the program can be run encrypted without the running system having knowledge of the program or data, producing an encrypted output, which can later be unencrypted by someone who has the key. This is so trusted computing can run on an untrusted system.
** Many have thought of this idea before, and it's an area of active research how to do this with any semblance of efficiency. See Wikipedia:Homomorphic encryption. I certainly think it's esoteric. Also there's already a similar item below.
* A language that holds a list of seven functions, and those are the only ones you can use. After using one, it is replaced with another like a deck of cards. Changing a past function (though not the data) will change a random "card" in your "hand" to that function.
** This is oddly similar to Snowflake, although I wasn't thinking about it at the time.
* Simon Says! Any command that doesn't begin with "Simon says" isn't performed.
** Please Porige Hot is similar.
** Literate programming is also similar, yet, far from esoteric.
* A language that uses rhythmic pressing of keys on the keyboard as input.
** It could be called Airdrum.
* A programming language that modifies its source code at runtime and, at each step, does some operation on its entire source code (such as %3 or MD5) and uses this to determine what it should do next or as an additional argument to the next line to execute. It would be very sensitive to whitespace and comments, though, but it would already be horrible to use that that would be okay.
** See Malbolge, though that is much much worse than "horrible".
*** Malbolge only modifies one command per step though, not the whole program.
**** Oh, I meant that it would use some property of the source code to determine what to do next, not alter the source code and then proceed.
** Similar idea: The hardest language to type in: the interpreter does an MD5 hash on the source, treating the result as some intermediate bytecode, then executes it. Programming in this language would require calculating reverse MD5 hashes. Other one-way hash functions may suit as well.
*** Sounds similar to ShaFuck.
* A language where the math is done on Roman numerals.
** INTERCAL by default does this on output only.
* A pseudo-code interpreter, liberal in what it accepts (but not too liberal to be pseudo-code), implemented only in itself.
* A programming language that only accepts quines. A program that generates an error message (possibly due to its not being a quine) that's equal to its source is an acceptable quine.
** I just found out that a language called Muriel already requires the programmer to use Quines, though even better, it's a side-effect of the language's design rather than an ad hoc restriction. But it would be nice if a language like Muriel were made that has a more readable syntax and isn't a tarpit language. 
*** It's not strictly quines though but quine-like constructions, the whole program doesn't need to print itself, it needs to copy at least a part of itself in order to do any looping. There are several other esolangs like that, Underload and :/// come to mind, and lambda calculus/combinatory logic languages like Unlambda can be thought of that way too. Those three are all tarpits though.
** cat?
* A programming language where you don't get to write your own source code. Maybe you find it on Google, or maybe it comes with a directory of source programs for every size. What you get to specify is the grammar specification to translate it into an Abstract Syntax Tree that does what you want. Only pure EBNF is allowed. The programming language defines particular grammar symbols that you can use in the EBNF to create a meaningful AST.
* A programming language where it's impossible to make syntax errors. Just ignoring syntax errors doesn't count. No matter where you mistype, the program does something totally different, but still following logic. This will be very hard to design.
** it already exists and is called HTML
** Trivial: take a hash of the source, feed it in as a seed to a PRNG and take the first K bytes, and with 1, and interpret as a number for a NULL program.
*** possibly NOB?
* "Crab's Jukebox"-style programming language. (This is a jukebox described in one of Hofstadter's book. It is a very large one, with only one record, which seems ordinary. There are many record players which will move on rails and touch the record. Each record player plays different music from the same record.)
* A programming language where the operators for dealing with numbers includes things such as "count how many letters to write the word of this number in English", "count how many letters to write the word of this number in Latin", "remove all digits from the first number that match digits in the second number", etc.
** ~English looks a bit like that, although it lacks many constructs that would be required to interpret the above.
*** I think that those are just descriptions of the operators, and they would probably actually be represented more symbolically in the language something like englishCount(n) and such.
* A language that takes a number and equally distributes it to all the variables for each instruction. I've written the syntax (but no implementation) for a language like this, but is it a good idea? I've finished "Hello World" and "99 bottles of beer" on it.
** Feel free to create an article for it.
* A language that bypasses class of computable problems. Basically Turing-machine with oracle. It would have such operators as: "does this program piece stop?", "are these two functions equivalent?", "find the smallest number that this function accepts and returns True" and so on.
** The compiler implementation would be simple: the program would print unsolvable problems back to a human, who would solve them and return an answer to the program. It would basically be proof-assistant. With some caching this would bring a new era to programming.
* A constraint programming language with time travel in which inputs and outputs say when they're done. For example: input(2min)=output(1min) would output a minute after the program starts whatever you type two minutes after. This is essentially what TwoDucks would be if you set all the commands to operate with the values of the variables have at one time. Can someone understand this and explain it better?
* A language whose basic command structure changes based on the program's branch depth. For example, let's say that the command REMAIN replaces the MOD command when you enter a for loop.
* A programming language where its specification does not allow any programs which do not have bugs, because they would be impossible to write in this programming language, not because of nondeterminism or randomness or being explicitly disallowed.
* A golf language that uses Unicode characters. For example, there would be extra symbols (such as Chinese characters) for functions. The Chinese characters would have special properties: two characters in juxtaposition would be interpreted as two tokens.
** Already done (although not with the juxtaposition idea; that would be hard since not all combinations exist in Unicode)
* A programming language that allows (and forces you to use) keyword variable names and no parentheses, such that some AI is required for parsing. For example
 set set zero
 comment set two
 print of nine times two plus set comment ambiguous operator precedence, but "var" is more likely to get interpreted as a variable token, and "of" is used to assist statistical parsing
 print comment comment the second word is a variable, because "<BEGIN-COMMENT: comment> comment" is less practical
*An even longer and wordier version of this, where parenthesis are replaced by long "start x" and "end x" statements, and the whole program has to be on one line (just to confuse people):
 start program hello start subprocedure main start arguments end arguments start statement print start string Hello, World! end string end statement end subprocedure end program
would more sensibly be written
 program hello
 sub main()
 print "Hello, World!"
 end sub
 end program
* A programming language with say 5-6 commands that all edits a secondary memory, like a tape. When the iteration is done the secondary tape is iterated, and that tape can have commands for other things like input/output. Or you could take it one step longer and iterating the secondary tape can only edit a third tape, and when done the third tape will be iterated. You can add 1 more available command for each level of tapes you create and iterate. Like a recursive SMC kind of thing, more gold (available commands) the deeper you climb, as a reward system for the programmer.
* First, a specification for organizing structs and functions in Brainfuck. If you use a version of BF with program and data in the same address space, this is probably just a specification. The normal BF memory model might need a new operator for calling a function. Second, implement Protocol Buffers for Brainfuck using the Structifuck specification. This would be a program that takes a protobuf definition file and spits out a Brainfuck struct and functions to serialize and deserialize the struct.
* If you use a variable where a specific type is expected, it is an implicit cast and it changes the actual value of the variable to that casted value too, rather than only reading it, and there isn't much other way to affect values of variables.
* Programming language using TeX DVI output as the program code. (This would allow very powerful macros since TeX can use those to determine the output)
* A language that is similar to that in the Star Trek: The Next Generation episode Darmok. I don't know what that could mean with programming languages. Look up Darmok reviews online. Here is one: 
** The key feature of the Darmok language was setting an example. It barely had any verbs, instead a reference to local mithology was being made, pointing an analogy to the current topic. Darmok programming language should then have a lengthy "bible" - maybe a tutorial of some kind - with stories of people solving algorithmic problems. When we want to access some language feature, we make a reference to the tutorial. Say: sorting an array would be accessed as "Bob carrying his apples in a basket" - provided that in the tutorial this was the setting of the story that described sorting arrays.
*Programming language that is meant to be as easily understood / interpreted / compiled by space aliens as possible (or used by their universal compiler/interpreter software). Something like these, or these things need pages on this wiki: Algorithmic messages. Maybe some esolang just happens to be close to that? Also, using that kind of or similar programming language to communicate things that are usually communicated by natural language and pictures. Arbitrary choices in design should be kept to a minimum i.e. it should be as universal as possible. Then universal compiler software or universal interpreter of programming languages might be able to test all (or enough) possibilities of arbitrary choice combinations and automatically find the correct way to interpret the language. It may be necessary to provide sample input and output for the universal compiler.
*One opposite of as easily interpretable by ETs as possible, could be a language for encrypted computation, or in a way, a class of languages whose members are generated from an encryption key. If someone sends data to get computed on a remote untrusted computer owned by someone who rents computing resources commercially, the data would be transformed and source code compiled to that language before compiled to machine code, so that it would be practically impossible to know what the data is and possibly also even what kind of computation is done on it.
**There is research trying to make something like this - and unfortunately also proofs limiting how close you can get.
** This exists: see Fully homomorphic encryption. This only covers addition and multiplication, though - anyone feeling ambitious might try to implement a homomorphic Brainfuck interpreter. Snowyowl (talk) 18:03, 21 February 2013 (UTC)
*Even if the source code of a program is published and checked ok, there is at least a theoretical possibility that the compiler could have been rigged, as explained in this article: Strange Loops: Ken Thompson and the Self-referencing C Compiler. Longer version: Reflections on Trusting Trust Maybe some kind of random language or language somehow involving public-key cryptography or homomorphic encryption, possibly run by an interpreter could be more secure in that regard? 
*A language which has programs that can be combined in a similar way that DNA combines in fertilisation / conception. Possibly it could be made to work even with more than 2 programs (3 or more programs combining)... For every conception / fertilisation there is a random seed involved or it happens in some kind of optimal way that is the only possible.
** Can't wait to try the interpreter :).
*A language which simulates actually using LTO ultrium type tape storage medium for virtual memory, instead of hard disk, but in smaller scale, so that "RAM memory" and the "tape based virtual memory" are both maybe just few kilobytes or megabytes. (unlike, for example, VHS cassette, Ultrium cassette has many parallel tracks or track arrays which can't all be read on one pass. Tape reader/writer chooses one.)
*Language with 1 or more very unrandom access memory system(s) (as opposed to random access memory RAM) simulating cables where electricity goes really really slow, so that 1 second transmission-receiving-retransmission cycle at 1 Mbps stores 1 million bits to that cable. Then a data cell can be accessed once in a second in some precise moment.
*Language that forces to replace normal computing with memory lookups as much as is possible. Snippet parts of computation are stored in memory as ready answers, before execution, by a separate program made in normal language. Then during execution, the ready results are combined in some special way, in loops with if then s etc.. The answer table could be gigabyte in size. Possible category would be Memory hungry in addition to resource hungry.
** This is already done, useful and has real industry applications. This is basically the memoizing feature of any stateless-paradigm language - functional or logic. The idea is to write your program as pure functions, with no side effects, then apply some caching feature on them. When we have an argument and the function has returned a result, this argument and result are stored in a cache. When the same function is called with the same argument again, the value is fetched from the cache instead of evaluating the function again. In a production process, a programmer writes the code then runs it on some profiled data input. The first run generates a cache which is stored in a file. Then, both the code and the cache are released as the application. This approach may decrease the CPU usage dramatically, at the cost of more RAM usage. It is somewhat analogous to compilation, with the difference that some statistical properties of the program input are known at the compilation time.
*Esolang for making a computer hardware, instead of esolang for making a computer software.
** See: Esoteric Verilog
*If you assign a value to a variable which has already been assigned a value and the new value is different from the value it already holds, the result is undefined.
*A language with an execution model based on refactoring and/or optimization. For example, turning a = false; if (a) { b = 7; } into a nop is really just a rewriting step. You'd presumably need to add a couple of "pathological" refactoring rules that don't always terminate in order for this to be Turing-complete. Obviously those ones wouldn't be optimizations in any true sense, as they would make the program longer. But you could probably have it so that all the program transformations are semantics-preserving. You could also combine this "refactoring-as-execution" process with executing the program that's undergoing refactoring somehow, too, but if so, it should ideally be combined in a peculiar and disturbing way.
** If you look at it on an angle and squint your eyes, lambda calculus beta reduction could count for this.
*Input caused by evaluating non-uniquely defined expressions. For example, sqrt(x) causes a sign to be read unless x = 0, or x/y causes a real number to be read when x = 0 and y = 0, or arctan(x) causes an integer to be read.
**Befunge actually has something like the second case; when division (of say 5) by zero occurs, the implementation is supposed to ask the user, "What you want 5/0 to be?" (But I'm not sure that behaviour ever made it into any spec.)
*Esoteric programming language designed to compile into Z-machine.
*Matrioshka languages in which te first phase is a pure functional language that is unable to initiate any I/O, and the second phase is a series of OOP class definitions which rely on the first phase for defining constants and any operation other than assignment and non-recursive calls.
*Generalization of the above: Matrioshka languages with numerous phases in which each phase represents a distinct paradigm. However, all but the first phase is unable to define any operation other than assignment and non-recursive function calling without calling the previous phase. As well, all but the last phase can only perform computation or I/O through being called by the next phase.
*An esoteric programming language based on Minecraft, e.g. you can create servers. Alternatively, an esolang designed to compile into MC.
*An esoteric programming language that tries to eliminate the use of microscopic steps via even more microscopic steps.
*A language that can't be ported to Android because it uses two different files (or directories, or a file and a directory) paths to which only differ in capitalization
*A language that is more low-level than Assembler because it reflects how modern computers work.
* Programming language with all flow-controls being executed forward and backward at the same time.
* A language that use Aurabesh letters.
* A "proprietary" language. The specification, documentation and implementation are publicly available, but nobody except the author can write any useful program, because each valid program must be signed with author's private RSA key.
** See Proprietary Esolang.
* NetProgramming: A programming language deteriative where functions are stored in a database and a number will repersent the function which will be executed. For example, if Brainf*** had a NetProgramming deteriative, then if the number 19373087 repersented a truth-machine program in the database, then in this deteriative, the compiler will download the truth-machine function/code from the database. Then the truth-machine program can be the number 19373087 alone. Users may submit their own code as functions to the database, making a code sharing platform. --Yes (talk) 18:31, 7 July 2022 (UTC)
** This is a simple application of cryptographical hashes, use a version 3/5 UUID to uniquely identify any piece of code in the language in standard format. The created UUID/GUID is the program for your *any language* interpreter. Rdebath (talk) 07:39, 16 July 2023 (UTC) 
 uuid -v 5 00000000-0000-0000-0000-000000000000 "brainfuck:$(tr -cd '<>+.,][-' <misc/HelloWorld.b )"
* Programming language using TRON character encoding and TRON file format.
* You can have a lot of fun in a language specification by defining the program to run into undefined behavior in certain conditions that the implementation doesn't actually care about. You don't even necessarily need a language for this, you can do the same with a library for existing programming languages. You can have any call into your library cause undefined behavior unless you bought a valid license for the library implementation, or for the associated patent, even per user. You can cause undefined behavior unless the user uses the program for good, not evil; or if the user is pure of heart or worthy; or if the user truly believes in the main tenets of a religion.
* Language written in D'ni, the language of the D'ni and Ronay in the Myst series. Depending on how feasible it'd be to implement the grammar of the language, it could implement the constructive nature of it (affixes, semantic context, maybe even actor focus for things like methods). It'd also just look cool because D'ni characters are super pretty. Plus, it could go one step further and adopt the base-25 numerical system that the D'ni use! (For reference: the D'ni dictionary.) — GemedetAdept (talk)
* Language written? adapted/translated? in the native tongue of Guåhan, fino' CHamoru (Chamorro). I've been learning the language and I think having a programming language written in it would help with learning it and just generally be rad! — GemedetAdept (talk)
* Language written in Hittite cuneiform. This one would just look ridiculous, and would therefore be incredible. (For reference: Hittite lemmas on Wiktionary.) — GemedetAdept (talk)
* Language where, as a compromise between using GO TO and COME FROM, requires you to use both to do the trick.
* Language based on Panex. Possibly using an infinitely tall version of the puzzle for data storage?
* An esolang that's made as if it's a conlang for humans/human-likes to speak and write. Probably makes more sense in a story than anything else.
* an esolang where the code modifies the order of operation(more than just basic algebra) for a set of pre made equations
* Language that is dynamically typed, memory safe, lets you store aggregate types only on heap by reference, but has no automatic destructor calls.
==Based on dimensions==
* A language with memory stored in n dimensions, where n may be increased during runtime, but with fixed length of one side of the memory.
**This sounds like NDBall.
* Language based on software emulation of a Rube Goldberg machine.
** It could be akin to Befunge with event propagation.
** It could have "bridge" constructs which are continuous when traveling in one direction but hitting them from another direction "knocks them over," perhaps until they are "stood back up."
*** I see toppling dominoes.
** It could be self-modifying with machines which move their parts.
** This has been done before: see RUBE and RedGreen.
** I'm toying with a more useful version of the above languages. It would appear and run similarly to The Incredible Machine series of games, but allow for useful programming through an assortment of objects. For example, a file-reading object would spit out a file as an in-game sheet of paper, its mass determined by the size of the file. Glue could concatenate, while scissors could obtain substrings. A sorting machine would fire crates to the left or right, depending on if they were green or not, functioning as a simple if-else clause.
** A language based on multi-dimensional Rube Goldberg machine.
* A language based around rolling ball sculptures, including switches, etc. I have a prototype, but I'm not sure what it can do yet.
** This gave me an interesting idea. Imagine a 2D area with each cell containing an instruction. Place a variable number of 6-sided cubes on the area. Each cube has instructions on all sides. Execution takes place as the cube tilts over, with the action defined based on the combination of the instruction placed on the current cell and the instruction on the cube-side touching the cell. If the cube hits another cube on the area, motion and execution is passed on to that cube, as a serial reaction. Before the cube "rolls" away the instructions are switched: the instruction on the cube is printed onto the cell, and the instruction on the area is sucked up onto the cube.
 !S F<E1,@prntpth @end> E<E1,D1,E1,F1> D<B1> B<E1>
 !F all 0
 !O ?this is a prototype example of this, printing FEEDBEEF.
:: The first line creates switches, the second puts them all to 0 (left) and the third line starts the ball at F<>. It isn't very efficient. The question mark is comments.
* Variable-pitch funge.
* ANSI codes funge with self-modification. So if you add a shift-in or shift-out command it can affect other parts of the codes too, and if you add a color code, it can affect the other commands following it too they will be a different command since they are of a different color, and adding cursor movement commands will cause the other commands to be moved around...
* A n'th dimensional programming language. The amount of dimensions increases with the size of the sourcecode, leading to a sourcecode of 2 bytes is 1 dimensional x (or 2), up tp 4 bytes is 2-dimensional x*y (or 2*2), up to 8 bytes is 3d (2*2*2) x*y*z, up to 16 bytes is 4d x*y*z*d1 (or 2*2*2*2) and so on. That will result in a multidimensional memory/code storage where all bytes is adjacent to each other no matter the size of the code or the memory. A sideeffect will be that the amount of directions will increase as the dimensions increase.
* Funge like where the acceleration changes rather than the direction (although you can change the acceleration in any directions).
* Language that can only be manipulated through time. For example, to add 3+2, you would time a wait of 3s and 2s to get 5s.
** TOD may already qualify.
** Stopwatch
* A language based on origami. Folding and unfolding of the source code could play a key role in its control flow. Moving up or down between layers of paper could allow the program to "teleport" to different parts of the code. Conditionals could be built by making folds that "lock" previous folds in place, so that an attempt to unfold them fails conditionally, changing the course of the program. (Making an interpreter for it would be quite a challenge...) There could be also code both in the front and back of the paper and a command to flip between sides.
** Unfolding locking and unfolding would be the most difficult to implement.
** There should be cutting too, but that complicates things even more. It would be needed only if there was no memory only the folds.
** If the program and it's folds and cuts would be it's memory, there should be a way to extend the program on one side at runtime. (that would fail conditionally too)
* Most programming languages have a 0D pointer (a point or small shape) moving through the program code. What about an esolang with a 1D pointer, say an infinitely long line or string, which reads 1D commands (not sure what those would look like) from the code space and executes them.
* Generalize the concept of different "fixes" (infix, prefix, postfix) to multi-dimensional source code. This is different from a fungeoid, because rather than executing one instruction per character, it evaluates multi-dimensional expressions.
* A computation model where the program is a graph, like in the first part of A Simple Universal Logic Element and Cellular Automata for Reversible Computing (note: I find its reversible Turing machine construction over-complicated), but it's only Turing-complete if there are at least a certain number of dimensions (that might be possible because the infinite extension seems to have to be periodic)
** Here's an idea for one that is TC in at least 2D: there's a single IP that moves based on whether it had already visited the neighbors, but can't revisit elements.
*** To come up with this idea, I first came up with the following: like a CA, but for arbitrary graphs (as required by the idea) and where every cell stores its own rule, but it can only switch from 0 to 1. After that, I thought of another version it's like the third one (described above), but it could revisit cells. However, a Minsky machine can be compiled into the second one of these earlier versions with 1 dimension, making it Turing-complete. It's easy to compile the third one into each of the earlier two.
*** I think every such system can be expressed using the element from which the IP moves to one of two depending on whether a third one is visited; if the gate it should move to is already visited, it halts.
* A language based in a fractal space, where dimension may be non-integer.
==Graphical input and/or output==
(...for interpreter, compiler or the program)
* An image based language that follows a single line and the size of the spaces it encloses.
* A language that uses the frames of a PNG or GIF image file as code.
** Braincopter, Brainloller, and Piet use PNGs as source, but a language that used the frames of an animated GIF (a three-dimensional language?) could be interesting.
** See Gifunk. (It's currently incomplete)
* A interpreter that uses I/O to get fractals. The fractals are partially evaluated based on the view size, and commands are executed based on the shapes of the fractals. Some commands zoom in the fractal, to uncover more commands.
* Interpret the lines on your hand as a computer program.
*Language with functions and classes that only draws/ describes pictures, and can be compressed into tight string. And can be used for image compression, so that if a compression program is presented with a picture, it tries to find the programs that draw at least some features on the picture. If the picture has repeating similar but not same features, it defines them with functions or classes. Depending on how lossy the compression is allowed to be, the compression program then can list pixel by pixel, in rows or in some more complex order based on the description, how much they differ from the original (and / or from some other pixel(s) like for example the previous pixel), so that lossless compression is also possible. In one area, the brightness value differences to original pixels could be for 95% of pixels, at most, for example 14, so 4 bits can express that difference, because 2^4=16. Exceptions - if rare enough - are best expressed by listing their coordinates or ordering number in a string of pixels. The image can be divided in segments that are either arbitrary squares or based on the features, and different rules and variable values apply in different segments. 
**Such compression would likely need thousand times more computing than jpg compression, but decompression would be "just" 2-10x slower. Video compression would not need so much more power, because same programs apply in different frames of the same scene. 
**If compression is lossy enough, the result will look artistic in a strange way.
**Metaprogramming features that allow to define what information can be lost and what has to be described more accurately. One definition file can be used for a type of photo and type of use for a camera. Aerial pictures (pictures taken from an aircraft) could omit water i.e. lakes, sea and rivers, meteorological pictures could omit ground, showing only clouds and sky and other photos could omit sky. Or high frequency small brightness changes or small scale turns in edges, or something else...
**Language can be used in a compressed format or shown in a readable format where it looks like some normal programming language.
***Minified javascript?
**Image codec file or video codec file can be decompressed / in a way "run" by an interpreter that can also be called an image viewer, video player or video transcoder, or first compiled to machine code and generated to a data file that the program uses. That program+data file may take less computing to show or play even if the computing needed for the compilation is counted.
* A programming language that reads in captions in anime for code and converts facial expressions to comments.
== Ideas related to esoteric operating systems, esoteric processors and esoteric computers ==
*Memory integrated multicore processor derivative idea: Use (in a simulation, or actually) of existing normal processors or imagined esoteric processors as processor cores that are on a 2D grid, each connected to 4 memory parts / memory cores and each memory part connected to 4 processors. 4 different processors read and write to 1 common memory core adjacent to all of them, and also to/from 3 other memory cores, each common with a different set of processors. Inversed situation for memory cores. Processors can communicate with each other only by writing to their shared memory cores. It turns out that 8 other processor cores can read what one processor core can write, i.e one processor core can communicate as directly as possible with 8 other processor cores. If 2 or more processor cores try to write to a same memory address at the same time, the simulation halts or maybe every core has an (arbitrary) priority number that determines which core's instruction gets executed, or something else... If there is 6*6 grid, it means 36 cores, 18 processor cores and 18 memory cores. If 8*8 grid, 64 cores, 32 each type, arranged like black and white squares in chess. On edges and in corners, the topology of the connections has to have some special rules. Maybe it wraps around to opposite sides to form a donut topology. Maybe some cores on the edges are meant to handle all input and output with outside, including with normal ram / dram / sdram memory chips. Maybe every processor has it's own input and/or output with outside. The processor cores could be based on any normal processor since 1970's, like Intel's 8086. 
**One possible way is to have a processor core type that has 3 byte=24 bit memory address so that it can point to 16 megabytes of memory around it, in 4 memory cores 4 megabytes each. In 16*16 grid, there would be 128 processor cores and 128 memory cores=512megabytes (+ram outside the processor).
**Just booting such processor would be strange, and it's OS would be strange inside. 
**It seems to be a possibility that with some sets of workloads, some version of it would be better than other kinds of processors, i.e maybe delivering more performance per transistor count, die area and/or watt. Also, it might be good with selective / level adjustable logical handling of physical errors ( radiation hardening / old chips / physically badly made chips / overheating / low power). In any case, this question should be addressed.
*** And it would be way faster than normal processors for programs that use some pure function with different parameters many times and need to do that very fast like matrix operations, 3D rendering, video games and such. With enough cores it may be faster than video cards for such things.
**Question especially related to esolangs is, what is the simplest processor core and smallest amount of memory in the 4 surrounding memory cores, that when in large enough such grid, is turing complete, and possibly also, can be booted from the edges?
**For extra challenge, cores could be in a random topology that is not known at programming time. Having some cores damaged would be one version of this.
**Possible name could be Bucket brigade processor because cores can move data between them like a bucket brigade to any other core or to/from some input or output.
* Similar idea to the above, but instead of separate memory parts and processor cores, every location on the 2D grid is a memory and a processor at the same time. The processor part executes code at a given location in the memory part, has read-write access to it's own memory and it's four neighbors' memories. Processors could overwrite the program of other cores, so it would be definitely possible to boot the entire processor by writing to the memory of one processor only. The memories would have a built-in lock feature like processor A wants to access memory B, locks some part of it and starts working with it. Processor B wants to access that memory too, but has to wait while it's locked by processor A. Locks wouldn't lock reading, only writing. The registers of the processors would be accessible only to them. The program counter would be accessible to neighbors too.
* The new sub-lime - sub-lime.org projects:
** The EsoShell and EsOS projects:
*** EsoShell would look something like this:
 * * * * * * * * * * * * *
 * Sub-lime EsoShell 1.0 *
 * * * * * * * * * * * * *
 -b >+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.
 Hello World!
 -b
 ,[.,]
 ^D
 Hello World!
 ^D
 Hello World!
 
 -bf 0"!dlroW ,olleH">:#,_@
 Hello, World!
 -///
 / world! world!/Hello,/ world! world! world!
 ^D
 Hello, world!
 -
*** Esoteric programming language compiler collection: the compilers convert the other esoteric programming language code to the sub-lime bytecode format (for example, ­ splits instructions in the bytecode format) and the master compiler which converts the sub-lime bytecode to the operating system's native code.
*** EsOS executable files is exactly sub-lime bytecode format and the default EsOS shell will be the EsoShell.
** Everything at sub-lime.org will have an "EsoShell GUI" skin.
** URL cipher projects:
*** http://fal.se/
**** Sadly doesn't work, but instead leads to a completely different Swedish website. europe :D 18:38, 6 June 2024 (UTC)
*** http://brainfu.ck/: For example, http://brainfu.ck/ will be encoded to http://brainfu.ck/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++..----.------------------------------------------------------.-----------..+++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++.-----------------.++++++++.+++++.--------.+++++++++++++++.-----------------------------------------------------------------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++.------------------------------------------------------------.
*** http://prelu.de/
**** Sadly doesn't work, but instead leads to a German error. europe :D 18:38, 6 June 2024 (UTC)
** This wiki will be at http://wiki.sub-lime.org/ and the esoteric file archive will be at http://farch.sub-lime.org/
*Operating system and compiler that are meant for circumstances where the computer makes lots of physical errors
** for reasons like:
*** it gets barely enough electricity, almost too low power, in a deliberate tradeoff to exchange reliability for energy saving, like this , but with current hardware.
*** it is under radiation (for example, in space, or near nuclear disaster) 
*** it has became old and weared out (does anybody know how current 35nanometer-detail processors start to work after 10 years?)
*** it is overheating but not so much that heat switch works (then the heat switch threshold is higher than what is normally wanted.)
**Most or some things would have to be stored and computed 2, 3 or 4 times for reliability, and it would be more efficient to have a language which allows to define and choose what things need to be more reliable (+slower) and what less reliable (+faster). 
**Operating system has to try to avoid memory addresses which are physically damaged, and circumvent calculations that tend to give wrong results because of damage.
*OS or linux distribution that proprietary software developers can adapt to run their software in a way that is difficult to tamper with, more difficult than with punkbuster or iOS, and also would make their software dvd or blu-ray disc bootable. Would have usage at least with multiplayer games. Some other (free) software like a web browser or voice chat could be included. License may have to be other than GNU GPL.
*OS that mixes, scrambles and encrypts some of it's core parts in a way that writing a virus etc. for it would be very difficult compared to others. Every application would have to be compiled with an encryption key specific to the OS instance. Running of programs gets slower and takes more memory if enough bits from the key are taken into account in the compilation process. That is why the programmer may have to be given choice to scramble some parts of some programs less by giving special codes in comment sections of some (almost) normal language that the special compiler takes into account.
*Modification of some kind of open source virtualbox virtual machine or sandbox, so that it can work as if the "machine" is overheating without heat switch working, or under radiation. What is remarkable about this kind of approach, is ability to "radiate" just one application or process at a time, if needed. This will reduce speed, partly because the virtual machine has to handle it's own random numbers that are used to simulate the randomness of radiation and heat. 
**Also emulate disk errors, hardware swapping while turned on, HDMI, etc
* Crystal processor.
* NybbleScrambler.
*Instructions composed from pieces from multiple locations, pointed to by multiple instruction pointers. Could also be the basis for a 2-D language.
* Intelligent quotient operating system.
* Something whose name is something like “GNU/Linux <something starting with O, e. g. Optimized>” so that it is abbreviated as GLO (which is a prefix of the word “GLOBAL”).
* An operating system with GUI that is entirely powered by AI.
** You can already use ChatGPT, including as a bash shell, but it doesn't have a complete GUI (with the image generated by it) and probably can't deal with real disks.
** Package installation can be done by training it to run the package.
* A GPU for which the only thing it can run is neural networks of a certain type.
** Technically, an (analog) processor like this already exists and is called brain.
* An operating system with a Desktop Environment/Window Manager where windows can be rotated, reshaped, or even moved in 3D space.
** I think Microsoft implemented something like this with their HoloLens (2). --Gilbert189 (talk) 06:25, 27 November 2024 (UTC)
* An operating system with "magic" directories. These directories have the pseudo-node ... and represents nonexistent files and directories that the directory could've stored. We can't read or write to ..., nor can we be sure what ... stores exactly. What we know is that the contents of the magic directory influences what ... represents, and writing to the directory will change the representation. 
** Perhaps an example could help.
 ~ $ mkmdir magic
 ~ $ cd magic
 ~/magic $ ls
 ...
 ~/magic $ cat > "test1.c"
 #include <stdio.h>
 
 int main() {
 puts("1");
 return 0;
 }
 ~/magic $ gcc test1.c -o test1
 ~/magic $ ./test1
 1
 ~/magic $ # See the "..." in action
 ~/magic $ cat > "test2.c"
 #include <stdio.h>
 
 int main() {
 puts("2");
 return 0;
 }
 ~/magic $ gcc test3.c -o test3 # "test3.c" isn't stored in the directory
 ~/magic $ ./test3
 3
 ~/magic $ ./test4 # "test4" isn't stored as well
 4
 ~/magic $ ls
 test1.c test1 test2.c test3 ...
 ~/magic $ # Implementation of magic directories need to handle unexpected or ambiguous cases (whether deterministically or not).
 ~/magic $ ./testA # This case is unexpected and might be ambiguous. While A is not a number, it is not stored as such in the source.
 A
 ~/magic $ ./testA # It is also valid to reject the existence of this file for not giving a number.
 sh: ./testA: No such file or directory
 ~/magic $ cat > "printf1.c"
 #include <stdio.h>
 
 int main() {
 printf("%d\n", 1);
 return 0;
 }
 ~/magic $ gcc printf1.c -o printf1
 ~/magic $ ./printf1
 1
 ~/magic $ ./printf2 # isn't stored
 2
 ~/magic $ ./printfA # Since 1 represents a number, not a character, the magic directory could reject this file's existence.
 sh: ./printfA: No such file or directory
 ~/magic $ ./printfA # It could be the case that the magic directory instead "perceive" A as a character (a pointer in C), and outputs it as an integer...
 4202512
 ~/magic $ ./printfA # ...its ASCII representation...
 65
 ~/magic $ ./printfA # ...or the proper character.
 A
== Ideas for Names ==
* The BBC magazine quiz "7 questions on computer programs" contains the following question: "Which of these is not the name of a programming language: Feta, Ruby, Pizza, Python?" Therefore, the world needs a programming language called "Feta" just to prove the BBC wrong. (Note: I swear an earlier version of this question on this quiz contained a different list of names, of which they claimed "Concrete" was not a name of a language -- were they already proven wrong once?)
* A language whose instructions are all Latin characters, and whose name is a self-interpreter in that language (and for bonus points, is less than fifty characters long (and for super bonus points, arguably pronounceable.))
** The simplest way to do this is probably a Shove derivative with input, and flow control that works by deleting the current row.
* Language named P3RKELE. (Finnish swear word. Maybe the most powerful one due it's very harsh sound. Literally translates to 'devil', but can be translated to 'fuck' in uses of swearing)
** That language should be 'Perkeleen vaikea' to use.
* To prove BBC right, I made a Pizza programming language.
* ><> (fish) derivatives:
 <>< (backfish)
:
 v (clockwisefish)
 ^
 v
:
 ^ (counterclockwisefish)
 v
 ^
:
 ><:> (flatfish)
:
 [censored] ><> (f*shfuck)
:
 [censored] <>< (f*shsuck)
:
 0157255><> (deadfish)
* brainfuck equivalents:
: eyefuck, family of languages identical to brainfuck, except that similar characters are used: 
 S$s52zZ~
:
 [](){}<>
:
 i!Il1|[]
:
 pqbdP96G
:
 :.,;'^`"
:
 etc. 
:* (not by the original idea author) My favorites are v
^
v, ^
v
^, and 0157255><> (there is already Deadfish)
* embrace, lisp derivative, the only bracket characters are used:
 []{}()<>
* A name that starts with a non-Latin (e. g. Cyrillic or Greek) letter. (Already exists)
* A name that differs from another esolang name only in capitalization. (Already exist)
* A language called Brainf*ck that is different from brainfuck (but can be its extension) (Already exists).
* Same for Brainfreak
* 1-866-025-4037 or other similar names (That's the decimal expansion of 1+sqrt(3)/2. This page may have to be created by a moderator)
* Balletic - see above.
* Two languages under completely the same name (probably already exist) EDIT:Yes
* Pick a language with a finite set of commands (preferably one where the language name ends the program) and make an esolang for each of its commands as the name
* Ftact
* The name similar to "NetVoble"
** Probably a FuckPutin derivative
** Using it can probably be considered discreditation of the Russian military (IDK how, but there were cases)
* (Inspired by COBOL and GL) An esolang called hare
* "Warma" for no reason, just "Warma"
* Name multiple unrelated esoteric languages of different characters from the Iliad or the Aeneid who share their name. In particular, name four languages Melanippus, disambiguated by which chapter of the Iliad they appear in (chapters 7, 15, 16, 19 respectively). Whenever you talk to them, just call them Melanippus. If someone asks you to clarify which Melanippus, answer “the Troyan warrior killed in the Iliad” since that still describes three of them.
* A name based on pure fiction (like the fiction the creator that just came up with or made stuff about it but never got recognised)
== External resources ==
* -- Chris Pressey's List of Unfinished Interesting Esolangs