User:BoundedBeans

From Esolang
Jump to navigation Jump to search

Hello, I'm BoundedBeans!

Languages

Currently I have a lot of languages spread across many devices, so this may not be a fully complete list.

  • Execoil, a stack based esolang where the instruction pointer traverses the stack, so that the data is the program. Uses exclusively digits and newlines in the code.
  • Sugueziume, a sequel to Execoil with letters rather than numbers, a queue rather than a stack, and interleaving rather than concatenation. I couldn't figure out how to prove its computational class, so I invented Sugueziume++ (under the same wiki page), which is still unproven but adds many nice features, including even stuff as high level as exceptions, multithreading, and networking with the SugueziNet specification.
  • Your stack may be eaten, where the stack gets appended to the code, one character at a time, after every command. Created in only an hour.
  • Mascarpone Joust, sort of like BF Joust, but for Mascarpone, my favorite esolang.
  • Matrixpone, a variant of Mascarpone adapted for a 2-dimensional tape instead of a stack.
  • Deadfish PDA, specify push-down automata with Deadfish commands. Thanks to User:PythonshellDebugwindow for the interpreter and Truth-machine example.
  • Deadfish TM, specify Turing machines with Deadfish commands.
  • Impfish PDA, a variant of Deadfish PDA adapted for imperativity rather than declarativity.
  • Diexponae, specify any Quadratic Bounded Automata (like linear bounded automata but with quadratic tape-sizing based on the length of the input rather than linear.). I actually couldn't find anything covering this concept online, I would assume it's a separate class from LBAs because it can solve more problems, but isn't as powerful as a TM because of still finite memory, but please correct me on this if I'm wrong. (I really want to know if there's any sort of information on what Quadratic Bounded Automata can solve, and I have no idea how to figure it out.)
  • XYZ?, a language that can be interpreted by a Deadfish PDA program along with a feeder program that feeds the XYZ? program in a loop as input to the former. Two versions exist, XYZ? Native which can be directly interpreted by Deadfish PDA and XYZ? Assembly which describes the instructions in plain English and must be compiled to XYZ? Native before running it.
  • Bidiroop, a mostly non-esoteric object-oriented language with the quirk that non-static methods must always return a dynamic class.
  • Thrillodendron, an object-oriented language where every single level of nesting of value, class, method, or almost anything else requires an increasingly absurd amount of escape characters since the way to write it as code is always a string.
  • Classtennis, an object-oriented language where you must throw away classes as soon as you make a single object with them.
  • 4est, my first well-defined non-Brainfuck derivative esolang. Incredibly bloated with features and features a forestry/plant conservation theme to the command names.
  • TError, every bit of data (apart from a few small bits) is an error that can be thrown or caught.
  • AI-Generated Esolang, an esolang with a specification developed by InferKit. I had to interpret most of the meanings in weird ways since the AI wasn't super coherent.
  • ExtendedPig, Pig and its variants except with way more features and Turing-complete with at least 13 files (code and data combined).
  • 99 bottles of pain, an esolang where one instruction is represented as the errors in an entire verse of 99 Bottles of Beer on the Wall.
  • PLAWIHA, an esolang where the only characters that matter are Unicode combining diacritical marks. Turns out this has been done before, see Zalgo.
  • O_o, a Brainfuck derivative with a stack attached to each cell, except each pair of commands is represented a monstrous eyebrow-raise emoticon with many eyes. Thanks to Kaveh Yousefi for the interpreter and correcting one of my example programs.
  • XERO, requires tons of try-catches to do anything, features a 3 operand tritwise operator (ternary ternary operator) inspired by Malbolge's crazy operation, and has a finite tape that can be expanded only by adding a caught error trit to the end of the tape. Try-catches can be nested infinitely in finite text though, so looping is possible.
  • SOAP, the only storage is a set of integers. Props to Kaveh Yousefi for caring a lot about this language and building a massive interpreter with 1000+ lines of documentation.
  • WindowGolf, same semantics as Drive-In Window but golfable.
  • $3COND, the only loop is based on a real-time amount of seconds, but the timer can be restarted.
  • Lete, a language where any program can be made into any other program simply by appending additional code to it.
  • 2022, a partially string-rewriting language that also expands upon SMETANA
  • HQ9^, a mish-mash of a ton of different languages and weird features to make a really weird expansion to HQ9+,
  • Braimmental, essentially just Brainfuck, but every loop body is written in Emmental, but every command definition is written in Brainfuck, but every... to infinity.
  • PDAsephone, builds up a ton of push-down automata to make a Turing complete language.
  • Taglate, a queue based language where the queue can only be expanded by input or by converting the queue to a google translate URL for translating the given text from English to Spanish
  • G_arD^EN CorUtY@rD, kind of like Bitwise Cyclic Tag as a fungeoid; also intended to look like roguelike ASCII arts of gardens. Thanks to User:Salpynx for a Python interpreter with colorful ANSI graphics.
  • Daffodil/#FLORA#, Subleq but with capitalization of the word "Daffodil" (Daffodil) or any other word (#FLORA# [word]).
  • PriLogic, the only infinite data storage is a priority queue, but the priority can be changed.
  • THROBOL, inspired by bowling.
  • Half-Broken Car in Heavy Web Traffic, like Half-Broken Car in Heavy Traffic, but capable of acting as a network server. (I think more specification is needed for what the $ actually does (does it wait for a single connection, meaning the language is only capable of serving a single client, or does it create new thread for each client that connects as they connect, but the program continues? I think the latter is preferable, but makes the least sense given the specification). Anyway I had basically no knowledge of how TCP works when I wrote this; I was definitely experiencing the Dunning-Krueger effect then).
  • Ditch, a Forth-like language where every five commands the language changes to require an additional nested eval to run anything other than eval.
  • OATMEAL, brought to life from a dream I had about a special-character-only esolang which had separate meanings as a programming language and as a compressed recipe to make platters of multiple bowls of oatmeal.
  • Matrexp, an expression-based language, except that expressions are represented as 4x4 matrices.
  • Quassaunt, a stack-based language with only strings and sets as data, relying on eval for conditionals and looping.
  • Summatciin, a language where the only loops are mathematical summations that can be reset to the beginning.
  • DAWBridge, a column-significant (like COBOL) language which ultimately creates a music project for the Ableton Live software.
  • Auphics, graphical input, audio output.
  • Sprupine, sort of a second sequel to Execoil, data is in a balanced binary tree this time.
  • Prefunge, Befunge but preprocessed by the C preprocessor, and with the requirement that you must use the preprocessor in order to get any character other than AB() and whitespace.
  • ABCDirection, a fungeoid kind of like 2L, but with 4 commands instead of 2/3, 2 of them being direction dependent, and also you can only turn write, and also everythin g is a big rectangle of letters A-B.
  • ABCDirectionE, an extension of ABCDirection but with a 5th command for self-modification.
  • Semqain, self-modifying multithreaded queue-based Brainfuck. That's pretty much the best concise description of it, but it's a bit more than that description conveys.
  • Mendeleev, expressions are written as molecule notation, and variables are element names.
  • Matag, inspired by Emmental, but totally different, only possessing one rewritable command, and having a queue of mathematical matrices (as opposed to programming matrices, which have a different typical set of operations but are ultimately the same structure) as its only storage.
  • ¥́, a LISP-like language where everything is the Yen symbol with Unicode combining diacritical marks. Windows has a weird problem where the marks show up to the right of where they should be, so this page is best viewed on iOS (probably also works on MacOS given they're both made by the same company, but I don't have a Mac to test it with.)
  • The Rink of Insanity, sequel to THROBOL but skating inspired.
  • WIWH (and WIWH-IH), programs are music sample breakdown videos.
  • Ueck, everything is an expression, and parenthesis are required for every operation. Except that it's nothing like LISP at all.
  • DotNetOISC, a very complex OISC involving the dotnet commandline utility for .NET (Framework|Core)?.
  • Drive-In Window TC, like Drive-In Window but with comments and also Turing complete
  • Drive-In Window JSON, like Drive-In Window TC but reformed into JSON.
  • Onione, all data can only be obtained by taking pixels out of images of "a large pile of onions" generated by the AI Stable Diffusion 2.1.
  • DateTri, a BASIC-esque language where all data is either a date, a date, or a date.
  • Ixux, an object oriented language where the only primitive type is the string, strings are stored in files (which may use special paths to not actually create a physical file and also avoid using /tmp), and the only basic string manipulation functions are Unix echo, cat, cut, paste, xxd, head, and rm.
  • C@++, like my joke language C@ but much more suited for string-manipulation.
  • Qwhy, a fungeoid that aims to be as weird as possible (direction is diagonal, code is self-modified as if it were a queue, etc.)
  • HQ9+ with headers, originally by User:Cortex, but I specified and standardized it from the one example they wrote. Exactly what the title suggests, except that I added enough features to the headers to potentially make it Turing complete
  • SPARCs Fly, the only way to create mutable state (or emulate it at all, for the functional programmers), is to create virtual machines and interact with them programmatically in human ways (inputting through the keyboard and mouse, and getting pixels off the screen to retrieve data).
  • Underload:^:^, extended Underload essentially.
  • Harmonii, looping is only accomplished with a caveat of the main focus, which is patching methods in a way similar to the Harmony library for .NET].
  • Dreadow, a language where the color of any given character matters, making the code a mishmash of beautiful flowers.
  • GRUBBY, more like a computational analysis of GRUB2 bootloader configuration files than a separate language.
  • Genewrath, a strongly typed language where every type is generic (has type parameters).
  • Hyperheptefunge-98, a member of the Funge-98 language family on the Order-3 Heptagonal Tiling of the hyperbolic plane
  • !!brainfeed++, an extension of the !!brainfeed language to include loops and infinite storage in the form of three queues.

Jokes

  • C@, created and fully specified in just 3 minutes 36 seconds, and reportedly done in less than 3 minutes (exact time unknown) by User:Cinnamony.
  • Unfortunately, my first well-defined esolang was a Trivial brainfuck substitution. It is now detailed here.

Other stuff

Wikitext tips and tricks

Color in code blocks

Want your own manual syntax highlighting? Here's an example by User:None1 (you have to indent by a space and use span tags): 

for i in range(10):
    print("Hello, World!")

Code: 

 <span style="color:red">for</span> i <span style="color:red">in</span> <span style="color:blue">range</span>(<span style="color:green">10</span>):
     <span style="color:blue">print</span>(<span style="color:orange">"Hello, World!"</span>)

Tables in code blocks

Want tables in your code blocks? You can't use pre tags (they don't allow inner elements), and you can't use indentation (they don't allow tables). So I recreated a code block with just divs and styles:

hello a table follows
ab
cd
end

Code: 

<div class="rectwrap" style="white-space:pre;font-family:Consolas,monospace;background-color:#F5F5F5;padding:10px;border:solid;border-color:#F0F0F0;">hello
a table follows<table class="wikitable"><tr><td>a</td><td>b</td><tr><td>c</td><td>d</td></tr></table>end</div>

If you want the tables to be on the same line as a text character, you can do this:

hello a table follows
ab
end

Code: 

<div class="rectwrap" style="white-space:pre;font-family:Consolas,monospace;background-color:#F5F5F5;padding:10px;border:solid;border-color:#F0F0F0;">hello
a table follows<table class="wikitable" style="display:inline-block;margin:0px;vertical-align:top"><tr><td>a</td><td>b</td></tr></table>
end</div>
Retrieved from "https://esolangs.org/w/index.php?title=User:BoundedBeans&oldid=140932"