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.

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
 * Bugmaker
 * 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).
 * 1) Unfortunately
 * A language that requires input to be in the form of a properly formatted mla essay.
 * As an added bonus, require that programmers follow draconian grammar rules of standart written english
 * Drawkcab
 * 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.
 * 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.
 * 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:
 * 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.

ö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?
 * Isn't there already a language like that called "C"?
 * 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:
 * 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 Time Cube. 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".
 * An esolang based on Vogon poetry. The nonsense words are executed as a few instructions a word. Oh Freddled Gruntbuggly by Prostetnic Vogon Jeltz is REQUIRED to be a valid program in this.

Partially Silly Ideas

 * 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.
 * 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
 * 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 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 LambertW 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.

Looks Like
Ideas that look like something other than a programming language.

In Soviet Russia, "Hello World!" prints YOU!!!
 * A language written using ASCII art.
 * 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.
 * 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 " ". "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.
 * 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!!!
 * Hello World program would look like this:
 * 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) In Soviet, # declare module 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 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.
 * Maybe combine this with the 'Soviet Script' idea from the Jokes/Silly Ideas section. Something functional would look like:
 * 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.
 * A programming language that is comprised entirely of Duke Nukem quotes.

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).
 * 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
 * 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.)
 * 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!
 * 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. 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.)
 * 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).

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.
 * 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.

Mathematics

 * 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?
 * 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.
 * 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)
 * 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.

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
 * 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.

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.


 * Programming language which requires use of race conditions and bus conflicts in order to work.
 * Someone's suggestion is to name it after Rosa Parks.


 * 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 old-style.
 * 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.
 * Programming Language Using Role-Playing Syntax. Write code as if we are playing an RPG. The code looks something like a combat log of an RPG or AI script.

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?
 * 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.
 * 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 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.
 * 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.
 * "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)

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 " comment" is less practical 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 that allows (and forces you to use) keyword variable names and no parentheses, such that some AI is required for parsing. For example
 * 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):


 * 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   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.


 * Input caused by evaluating non-uniquely defined expressions. For example,   causes a sign to be read unless , or   causes a real number to be read when   and  , or   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.

Based on dimensions
!S F E D B !F all 0 !O ?this is a prototype example of this, printing FEEDBEEF.
 * 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.
 * 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.
 * 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.
 * 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.

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.
 * 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.

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.
 * 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.

* * * * * * * * * * * * * * 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! -
 * The new sub-lime - sub-lime.org projects:
 * The EsoShell and EsOS projects:
 * EsoShell would look something like this:
 * 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/
 * http://brainfu.ck/: For example, http://brainfu.ck/ will be encoded to http://brainfu.ck/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++...--.---..+++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++.-.++++++++.+++++..+++++++++++++++.---.+++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++..
 * http://prelu.de/
 * 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.

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.

External resources

 * -- Chris Pressey's List of Unfinished Interesting Esolangs