List of ideas/Archive

'''This is the archive for List of ideas. It contains any ideas removed from there for reasons of completion or triviality.''' (The cleanup is currently in progress, so this contains all the ideas. Ones that are kept in the main list will be removed from here.)

-

This is a list of ideas of programming languages and other stuff.


 * MISC-x86
 * Peyo
 * Magic The Gathering card deck of programming language
 * TIB and STIB
 * inflection
 * Stalactite
 * Primordial
 * PokéArena
 * Chess
 * Silly Emplosions
 * Two Fifty Six
 * Eitherf*ck
 * FRM
 * Drawkcab
 * Isolated
 * Black and white and read all over
 * Set Language
 * Timesig
 * Bugmaker (note that even though the language probably is turing-complete, i will probably add more to it)
 * Bool
 * Preposterous Programming
 * Rapture
 * Braille

Incomplete ideas

 * "Undefined Behavior" - a joke language whose specification is intentionaly 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, their good effects will not be documented though. Programming would require avoiding "traps", both included in specification and not.

PRINT "HELLO WORLD" STOP NEWLINE STOP 00Davo 03:23, 3 February 2010 (UTC)
 * Menu
 * Grocery List
 * Done: Grocery List
 * Braille
 * It would use Braille symbols of Unicode table (U+2800 to U+28ff) and its input and output would be 4-row punched tape. Sth like this: "⡤⡗⡥⠿⢝⢛⡁⢧⣊⣄⡣⠓⣼⡘⠸⠝⠊⡺⠉⠉⡫⢓".
 * Fractran with complex numbers
 * (see comment on Good Math, Bad Math article.) -- alhirzel
 * 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
 * Could be akin to Befunge with event propagation
 * 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.
 * Could be self-modifying with machines which move their parts -- alhirzel
 * This has been done before: See RUBE and RedGreen. --Ørjan 00:50, 28 Jan 2007 (UTC)
 * I'm toying with a more useful version of the above languages. It'd appear and run similarly to The Incredible Machine series of games, but allows 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 would obtain substrings. A sorting machine would fire crates to the left or right, depending on if it received a green or non-green object - functioning as a simple if-else clause. And so on. 00Davo 10:26, 15 November 2009 (UTC)
 * Befunge interpreter named "v"
 * If you used the interpreter named v in your path, then you could use #!v line to start your program, thus making it runnable without typing in the name of the interpreter at all. (ie, 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.
 * (didn't really know where to post this)
 * Any name starting with v would work too.
 * vefunge perhaps?
 * I would suggest something that can compute a line starting with #!/usr/bin/env - in b98, 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 to move on downwards. A good example for b98 would be the name 'j', which nops (twice) and hits the 'v' from 'env'.
 * A language based around rolling ball sculptures (switches etc.) I have a prototype but I'm not sure what it can do yet (I'm new, btw)
 * This got me an interesting idea: Imagine a 2D area with each cell containing an instruction. Place a variable number of 8-sided cubes on the area, each cube has instructions on all sides. Execution takes place as the cube tilts over, action is 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 is switched: the instruction on the cube is printed on the area, the instruction on the area is sucked up on the cube. --Peter Larsen
 * !S F E D B
 * !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.
 * 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.--wildhalcyon 14:44, 25 July 2007 (UTC)
 * 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 as 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.
 * Hmm... I think the code should be divided into two sections, one for "Data Processing Code" (This is the code you are trying to run, it 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) and "Survival Code" (This is the code that controls the player, it can receive all data that would normally be visible to the player, and uses 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 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?).
 * A programming language whose source code is in XML format.
 * Been done already (XSLT)!
 * A programming language that resembles a telegram, all uppercase with STOP in between commands. for instance: PRINT "HELLO WORLD" STOP NEW LINE STOP
 * or just maybe a programming language that looks like a letter to someone
 * Already exists. It looks like this:
 * 1) define STOP ;
 * 2) define NEWLINE print "\n"
 * 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) [or even just COOL]?
 * ("like" = "which would have similar language features to")


 * A language that only uses the homerow of keyboards for optimum typing speed. This would be good for mapping keys to game controllers so that programs could be written with 4 face buttons and a d-pad/analog stick of a game controller. Very comfortable programming.
 * Maybe you could make like this on Nintendo DS
 * I've invented one. See Home Row. PuzzleHunter84 17:13, 18 August 2009 (UTC)
 * The idea 2 lines below this one
 * A combination of all of the above ideas, but having as little resemblance as possible to any of the following ones.
 * An idea that can only be added in the middle of list, thus breaking the joke ideas that reference others.
 * A combination of all of the ideas below, but having as little resemblance as possible to any of the previous ones.
 * The idea 2 lines above this one
 * 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.
 * An image based language that follows a single line and the size of the spaces it encloses.(ie --[ ]--) are characters.
 * 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 (three-dimensional language?) could be interesting.
 * A language designed in such a way that souce code looked like poetry or song lyrics.
 * A langauge that uses a sound file and the properties of sound as code.
 * A programming language that consists entirely of pronounceable words that don't have any meaning at all. This would allow programmers to quickly speak and write code as if it really were a (foreign) language. So int[] x = {3,4,3}; might be "yor sawv ecks je fe di ank du ank la defe ile." The actual implementation may be more terse in some way.
 * I made this before with the intent of using it to cast spells in an RPG. Then I remembered how long programs are.
 * Someone has designed the opcodes of his MISC stack-machine processor to be two letter "syllables", like FA LO, etc. So common phrases would come out as multi-syllable words. It is an interesting concept!
 * One of the Forth standards (ANS Forth?) defines the pronunciation of each word, though of course you have to consult the standard, as the pronunciation isn't always obvious from the lexeme. Maybe IPA would help this.
 * Done. See SyL.
 * A language whose code consists solely of quoted strings as regex patterns, each of which is run over the program's own source code before the next pattern, which runs over the output of the previous pattern.
 * Already exists, see ///
 * A language that uses only the symbols ☺, ☻, and π.
 * Take any three-instruction language, like whitespace, and replace the symbols in the interpreter.
 * A language that requires you to use functions that are not called, and undefine all header files you will "not" use
 * 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.
 * 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.
 * Simon Says! Any command that doesn't begin with "Simon says" isn't performed.
 * Please Porige Hot is like this
 * Combine 2-dimensional fungeiod with an array, verb-stacking paradigm a la J/APL.
 * “qit, the quaject manager from hell”. (A pun on git, the “information manager from hell”.)
 * A Deadly Rooms of Death-based programming language, or something similar. There is a room with walls, switches, one-way arrows, etc., some monsters that move in specified ways (in DROD, roaches, roach queens, goblins, etc.), and 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 whose source code, input, and output are in png format, with an optional debug output that's text format.
 * A language that uses rhythmic pressing of keys on the keyboard as input.
 * It could be called Airdrum
 * ’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).


 * 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 and we would add more over time.


 * A programming language wich 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 wich will be involved in the function. So a source code can be played on guitar. :P


 * 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. Would be very sensitive to whitespace and comments, though (but it would already be horrible to use so that's okay)
 * See Malbolge (but this is much much worse than "horrible").
 * Malbolge only modifies one command per step though, not the whole program. --Ørjan 13:13, 19 April 2009 (UTC)
 * 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 than proceed. --Patashu 13:18, 19 April 2009 (UTC)
 * moved, overlapping idea: The hardest language to type in: Interpreter does an MD5 hash on the source, treating the result as some intermediate bytecode, then executes it. Programming in it would require calculating reverse MD5 hashes. Other one-way hash functions may suit as well.


 * A programming language in haiku format. A program repeats a pattern of 3 words, 5 words, 3 words, empty line and will not execute otherwise (the error being a haiku, of course). Could force interesting programming structure if there are things you can do with 3 words you can't do with 5 and vice versa.
 * See Haifu


 * INTERCAL in a language other than english.


 * A language that actually it is two languages. The program need to be valid in the two languages, and in execution there will be a thread for each language.
 * Complete idea: see Black and white and read all over


 * A language based on rick roll, where every line in the song does an action that is relavent to the line, like "never going to give you up" would protect a line so that it can't be modifyed, only read, and so on.
 * Or just a version of BF where all the commands are lines from Never Gonna Give You Up. ;)


 * 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?
 * How about a language that actually is ironic: each command does the exact opposite of what you'd expect. "print" is for input. x = y actually assigns y = x. And so on. Since you'd expect the commands to do the normal thing, and they do the opposite, that is ironic. 00Davo 03:10, 18 November 2009 (UTC)
 * Just like Soviet Russia.
 * In Soviet Russia, irony is lost on YOU!!! Oh wait


 * A language which is actually a list of instructions/keypresses which are input in a video-game (Quake, pacman, Mario bros, etc., with a predefined random seed of course ), and commands are executed depending on which enemies the player kills, the final score,etc.


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

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) 00Davo 01:07, 27 December 2009 (UTC)
 * In Soviet Russia, esoteric programming language invents YOU!!!
 * Hello World program would look like this:


 * one that the math is done on Roman numerals
 * INTERCAL by default does this on output only.


 * After each cycle the whole tape of a brainfuck program gets reversed and encrypted (XOR) with the number of cycles the programm ran mod 256 :)


 * Based on mahjong game
 * You could have a "mahjong operator", that does: If you have a tenpai hand (where a complete hand must contain any number of sets of three tiles and up to one pair), then the output will be the list of possible tiles to complete this hand.
 * This could be combined with a concatenation operator and condition operator, too.


 * A programming language that must be run with paper and pencil, possibly similar to CARDIAC Paper Computer


 * 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 somehow too. Also, I think music is supposed to have short periods of dissonance between harmony.


 * A language with only one command. Take the number of commands in base 8, and map each digit to a brainf*** command.
 * Already exists.


 * A language that has two commands, one " " and the other " ". "  " would move the command pointer foreward one step. " " would do the command.  The list of commands is the same as in brainf***.  The commands must be separated by any non-space letter or list of letters.  To print 'a' it would be (some spaces replaced by line break)

la la  la la la la la la la la la la la la la la la la al la la la la la la la la la al al la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la la  la  la la


 * A language based on the idea of communism.
 * Cool. There would be only one great editor (wiki or something) and all programmers would write only one big program that does everything.
 * And only one datatype that fits everything.
 * Yeah everything should belong to one single class.


 * Programming language with infinite dimensional program/data space
 * See Dimensifuck. --Ørjan 20:00, 15 November 2009 (UTC)


 * 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.  --Ørjan 21:57, 10 December 2009 (UTC)


 * 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 programme - Hiato 13:28, 5 April 2010 (UTC)


 * "Crab's Jukebox"-style programming language.


 * 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 program language that 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", and so on, like that.


 * A language that takes a number and equally divides distributes it to all the variables for each instruction. I've written the syntax (but no implementation) for a language like this today, 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 interprets Geek Code. Feuermonster 18:12, 18 March 2010 (UTC)
 * Geek code decoders already exist, unless you mean a language that looks like it. Phantom Hoover 18:57, 18 March 2010 (UTC)
 * I know @decoders. But I meant a language that looks like geek code. -- Feuermonster 19:42, 18 March 2010 (UTC)


 * 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.
 * Compiler implementation would be simple: the program would print unsolvable problems back to a human, he would solve them and return an answer to the program (basically it is proof-assistant). With some caching this would bring 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 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.


 * Casino Viagra program language, where the programs are going to be caught by spam-filter program and/or by anti-virus program.


 * 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 programming language with Egyptian hieroglyphics.


 * Variable-pitch funge.


 * To write an Operating system using one of the esolangs.


 * A language whose basic command structure changes based on the program's branch depth. 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 programming language based on some game such as cricket, or football, or whatever game.


 * A golf language that uses Unicode characters. For example, extra symbols and Chinese characters for functions. The Chinese characters will have special properties: Two characters in juxtaposition will be interpreted as two tokens.
 * Already done by me, although not published. I have a Word document describing all the commands, of which I have about 58. A quick sample: 長 = length of string; 加,減,乘,除 = add, subtract, multiply, divide; 數 = for loop; 換 = regex replace; 嗎 = conditional operator, etc. In theory of course one could have thousands of commands and thus create the ultimate golf language. I also wrote a whole IDE for this, which allows you to run these programs step by step and see the stack in the middle of execution. I didn’t publish it because the semantics are very boring: it’s a standard stack-based golf language, basically GolfScript with Chinese characters. Also it cannot do subroutines (nor can it do goto); everything has to be written in a single program, which makes recursion very hard. I didn’t get around to this because I then had the idea for Funciton which turned out much more interesting. If someone is interested in seeing the list of commands I have so far, and/or actually try the IDE, I’d be happy to publish it after all. — Timwi 12:38, 17 May 2011 (UTC)


 * A interpreter that takes an 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. The Chinese characters allows functions that solve common golf problems to be added.


 * A programming language that takes a mathematical expression, and the interpreter try to simplify it, and during the simplification, it will encounter side effect. 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 programming language that allows (and forces you to use) keyword variable name, no parens, and 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 " comment" is less practical

The parsers can be trained


 * Pure Unlambda, Unlambda without the `i` combinator and all IO operations, and lazily-evaluated data structures are used to define IO. For example, the Unlambda encoding of `1], (\x. [[2, x], 0])]` will be the [[cat program (1 means read line, 2 means print).
 * Lazy K is somewhat similar to this. It's not just `sk, it supports a lot of alternate syntaxes, but you can use just `sk.  It is completely lazy though, not just data structures.  --Ørjan 19:39, 16 May 2011 (UTC)


 * A programming language that is modeled after an infinite space with full of gravitational bodies (can be other forces) that are arranged in a pattern. A projectile will be shot from (0, 0), and getting close to different bodies will perform different instructions. The program is a only pair of full-precision floating point number, of the x and y coordinates of the initial velocity. *If the numbers have infinite digits, 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 a long research. (the simulation is performed in a certain unpredictable numerical method)


 * A combination of all of the above (and more).

External resources

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