Imaginary PLT: Programming Language Ideas

A collection of programming language ideas over varying degrees of surrealness and practicality. This list was inspired by Forty-Four Esolangs. These prompts are taken from my mastodon post. Most of these can be found under the hashtage PLIdeas.

The ideas

Prompt #61:

The points in your floating point numbers exhibit Brownian motion.

Prompt #60:

Eventual based programming language. Everything happens eventually in some order at some point, but none of will happen in a consistent order. The language has no data structures which preserve information about insertion nor sorting order.

Prompt #59:

It is a stack-based programming language where the pop operation makes you program carbonated.

Prompt #58:

An IF ... THEN ... statement that operates like p → q. That is to say that the statement is only skipped if the body is false and the condition is true. Thus IF false THEN ... is always executed instead of always being skipped.

Prompt #57:

A user of the language has a fixed number of tokens, as in they can only write 1000 syntatic tokens in this language before the program has to be passed to someone else.

Prompt #56:

The only data type is the sandpile grid. If you put too large of a value into a cell, it will start to flow into the neighboring cells until it reaches a sustaniable height.

Prompt #55:

The yellow interactive paint to mark code that can be hot reloaded.

Prompt #54:

Instead of guaranteeing your program won't crash, the language guarantees it will crash the moment something you didn't intend happens. For example, if the player can stand on a box while grabbing it causing them to, unintentionally, clip through the ground or other collision shapes, the runtime will crash with a debug trace for you.

Prompt #53:

It's a high-level programming language as in you must be a Lv 100 Mob Boss before using it. Otherwise the compiler laughs at you and your pathetic Lv 5 Gangster status.

Prompt #52:

The Callstack is a resource object in the language. All functions which call other functions take the form foobar(cs : Callstack, ...). If a function has not be given the Callstack, any attempt to excute another subroutine is an error.

Prompt #51:

System programming language as in it can only describe plural systems and also solar systems.

Prompt #50:

the programming language and development environment is an immersive sim.

Prompt #49:

It's a language programmed entirely through sourdough starters. The taste of the dough once baked reveals the results across your palate.

Prompt #48:

Inventing the OCaml of SQL.

Prompt #47:

Concatenative programming language where compositional operations are inspired by CSS combinators

Prompt #46:

The infix form of functions with arity n > 2 is simply further repetitions of the infix operator. f/3 is x f y f z, f/4 is x f y f z f w, and so on.

Prompt #45:

It's a language coded using the unhappy path. Your program is not what the computer should do, but everything it shouldn't do.

Prompt #44:

A dynamically typed programming language called Your Typechecker. The only I/O support is spitting out errors about type unification or "Ok!" if everything runs to completion.

Prompt #43:

Your programming language has native support for exporting and importating clay tablets.

Prompt #42:

It's a language designed to be program on an Upwords grid.

Prompt #41:

The documentation of your language does not explain how anything is intended to work. Rather, ir elaborates on all the ways any given operation can go wrong and how to recover back to the happy path.

Prompt #40:

A language truely free of any global state. Objects are fully encapsulate as in they have no means to communicate. There is no observable state to gaurentee there is no accidental formation of global information via any for of information sharing between object. Since everything is fully encapsulated, there is no means to starting a program. The world of this language is forever pristine and prefectly crystaline.

Prompt #39:

Your code needs to periodically shift and to and fro to keep the compiler from falling into a state of highway hypnosis and dozing off at the wheel.

Prompt #38:

It's a statically typed concatenative programming langauge. The runtime non-deterministically chains together compatible function signatures like computational nucleotides. Chunks of global state are feed through these computational chains before settling back into the global state.

This process is repeated until the program reaches an inert state.

Prompt #37:

The type system of the language requires objects have specific types of rotations symmetry. The language has support for higher dimensionsl shapes beyond 3D.

Prompt #36:

You take the moon and you take the sun. You take everything that seems like fun. You stir it all up and then your done! Radda radda radda radda radda ra.

Prompt #35:

Instead of a garbage collector, you have the antimemetic singleton. Objects which hold a reference to the antimemetic signleton object (ASO), will be erased from the system by it. This deletion takes some time and removing the references to the ASO will stop the process leaving an object partially deleted.

Prompt #34:

It is a pathologically structured programming language. The only control flow is IF/ELSE and AGAIN. AGAIN's only ability is jumping to the top of the program. Additionally, the language as nor RAM but rather a collection of stacks indexed by number.

"Jumping" to a different location in the program takes the form of [ path to subroutine ] AGAIN. The program then consumes from the primary stack as it walks a tree of IF/ELSE blocks. A call-and-return can be emulated using [ path to target 0 path to source 2 ] AGAIN where 0 and 2 represent where to enter path to target and path to source respectively.

[Relaized as AGAIN]

Prompt #33:

It's not actually a programming language your are just trying to coordinate and to complete a task. They keep blipping in and out of reality, getting distracted, and shuffling about. Some times task are left incomplete and another and has to take away to figure out what the previous and was doing. Occasionally an and appears and start doing already completed work cause it's unaware another and has finished it.

It is a concurrent trainwreck good luck.

Prompt #32:

The compiler is the development enviroment and that development enviroment is 3d sandbox capable enough to develop the compiler itself it. Code is objects in the 3D space that can be physically inspected within the game.

Prompt #31:

It's an object oriented programming language where objects can enter turnstiles to reverse the direction they are moving through time. Unfortunately, it cannot solve the halting problem despite best efforts.

Prompt #30:

It's an object oriented programming language in that objects have orientation in space. In order for an action to happen two objects must collide. Code then decides how that collision is resolve. Objects are destroy be absorbing them and not re-emiting them.

Prompt #29:

It's a stack-based programming language as in the height of your stack changes what base all numbers are interpreted as. For example 0 10 10 10 10 + is 1 + 2 + 3 + 4 + 5.

Prompt #28:

Do to the rising price of computing, all programming languages will have to be limited to just 3 variables. That's 3 for the whole program. Also, for import tax reasons, slots into an array or allocations under a pointer will be billed separately.

Prompt #27:

The language is finished. Not discontinued, not abandoned. The people maintaining the language have formally declaired that the language is done. The latest version is unnumbered, and is simply the language name. Any bugs found are not to be fixed but documented extensively.

Prompt #26:

Cotton, it has something to do with multitasking and is lighter weight than fibers and threads. Additionially you can form threads into spools and weave those into cloths and finally form clothes of concurrency. Your program is the local clothig store and you are the taylor and seamstress. Refining a program is now alterations.

Prompt #25:

It's actually not a programming language but a library implementing a collection of modules you can use for building a programming language. It provides you a collection of common design tropes, common type systems, and substructural systems. It can also let you compose together custom modules.

let another_better_c = 
    PL.c_like()
      .but_strongly_typed()
      .with_only_linear_values()
      .add_syntax(...)
      .make_parser()

Unfortunately you have to bolt on a backend yourself.

Prompt #24:

The compiler's memory is a ring buffer. Old data will eventually be overwritten by new data should the compiler run out of RAM.

Prompt #23:

Remove all forms of loops. There is no means of doing anything in a loop. Recursion included. The interpreter deletes the program to insure it can't be ran with new values. It refuses to execute code in the presense of git.

Prompt #22:

You compile coroutines to the following form:

function co(ip, state)
    if ip == 1 then
        ...first op...
    elseif ip == 2 rhen
        ...second op...
    elseif ip = 3 then
        ... you get the idea ...
    else
        ... all done :) ....
     end
end

I am sure this is not an original idea.

Prompt #21:

Meow mrrow rrreow purr meow rmeow rrrorw ruoh meow rouw meow mrreow meow purrr moew merr.

It's a catlang.

Prompt #20:

It's that small flame that keeps you going despite everything.

Prompt #19:

You data types are asigned rules the dictate what can be next to them in RAM. You cannot have homogenous arrays, as that's too boring, the integer type and floating point type had a falling out and don't want to be next to each other. The player type needs a string type next to it for emotional support.

Prompt #18:

It's write only code in that your ability to perceive the code is removed from you as you write it. It's a stack based language. Each word you type out slowly fades away into oblivion. The information is completely blocked from your perceptive reality.

All attempts to convey information about the program are immediately blotted out. Anyone that reads, records, or otherwise attempts to understand your program will be removed for your perceptive reality as well.

Prompt #17:

When you de-allocate memory, that block is permanently, physically, destroyed and cannot be used again. You will learn to recycle. Program efficiency is not measure in time, but how much it money it costed the user to run at the current RAM price.

Prompt #16:

It's a language where you can only define functions. There is no main program nor starting state. The runtime simple shuffles through all the units of code your provide it applied to a randomized starting state.

This language is of course inherently concurrent. Memory is manually managed because the creator unfortunately liked C a little to much.

Prompt #15:

Programming language ideas: a forth wheree dictionary entriesssss haaaaavvveee toooooooooooo alwaaaayssssss geeeeeeeeeeeeet loooooooonnngeer

Prompt #14:

Probabilistic ADTs. You do not directly construct any single value of the ADT, rather you construct a super position of all possibly values.

Prompt #13:

An LSP that explodes your computer if it detecte network request to an AI agent.

Prompt #12:

It punishes your hubris for having the gaul to write more code by becoming exponentially slower the more expressions it has to evaluate.

Prompt #11:

A structured programming language that enforced physical size constraints. Fuctions are declared as having a certain volume. Code fills this vomume up as the programmer writes. A function, F, with a volume of 11 cm³ cannot call a function, G, with a volume of 12 cm³, as G cannot fit inside F.

Prompt #10:

It's just cooking, the magic of culture and food. The result is hopefully a nice meal to have, maybe it reminds you of home or where you wish home could be.

Prompt #9:

Lay down somewhere comfortable, close your eyes and focus on a setting, and fall asleep. This language is nondeterministic so you man not run the intended program.

Prompt #8:

It's not a programming language, but two people that represent the toxic relationship between game developers and PLT. They hate each other but also desperately crave each other's validation. It's extremely unhealthy.

Prompt #7:

You sit quiet in the wilderness taking note of the bird songs around you. These songs encode some sort of program. Assemble your program into a new bird song. Sing it where you recorded your notes. The call you get back is the result of your program.

Prompt #6:

It's just an RPG you shout into your server room exploding it immediately. It's a language that works best inside a major data center.

Prompt #5:

Borrow checker, but it requires that all values are boxed with at least two references at all time. Both references must have write operations to them, otherwise the program is rejected for not having enough action at a distance.

Prompt #4:

It's a language where you have 52 snippets of code. You can only construct programs by pulling cards from the deck. No other code is accepted. All arrangements of this deck produce some kind of valid graphical utility.

Prompt #3:

The compiler statically checks all code in the language is no longer than 80 characters per line. It additionally checks that your program's total line count is less than 1024 lines. If either constraint is broken, the compiler errors.

Prompt #2:

It's an object oriented programming, however the only systems it can describe is intercourse between objects. It demands copious detail.

Prompt #1:

A programming language where code is entered by preforming tricks from Tony Hawk Pro Skater. The tricks and value of your combo are used to decide the instruction. Any combo worth less than 100,000 points is a no-op. Bailing at any point discards that instruction.

Tricks preformed too many times in a row become stale and the interpreter will ignore them.

Prompt #0:

It's a language that is coded exclusively in your regrets. Each regret is an object and the narrative of how it came to be defines its behavior. Coding in this language makes its users experience intense grief, grief that encodes the result of your computation. Tho, you many not be ready to receive it. [Realized as Regret]