Programming abillities of different esolangs

From Esolang
Jump to navigation Jump to search

This table shows programming abillities of esolangs. Created by User:None1.

Only a few languages are mentioned here by now, you can help by adding more or revising incorrect records.

Legend

Y: Yes

N: No

U: Unknown

Example

Brainfuck

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: Y**

Has self-interpreter: Y

Has interpreter: Y***

Hello World: Y

Code dependent: Y*

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N****

Turing complete: Y


* If a language is code dependent, that means the result of running it depends on the code. Most languages are code dependent, but some, like Nope. and APLWSI are not.

** Only non-empty quines are considered quines here, you can find Brainfuck's quines in here

*** A compiler or a JIT interpreter is also considered as an interpreter here.

**** Conditional operators are like if or if-else statements in C, so Brainfuck doesn't have it.

P.S.: If you have additional information, you can write it in the discussion, or write stars or P.S.'s like this one.

P.P.S.: Unimplemented programs but can be implemented are still considered Y, for example, if an esolang has no interpreter, but can have one, then the "Has interpreter" for it is still Y.Things are the same for cat programs, quines, etc.

Main Table

Sorry for the inconvenience, in order to prevent malformed records, anyone who wants to add esolangs in this article has to copy the text in the example and change the content.

P.S.: Please arrange esolangs in alphabetical order.

Non-alpha

!!brainfeed

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

!!Fuck

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

#b

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

<stack>

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

?!

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

(

Computable: N

Has Input: N

Has Output: N

Has Char Input: N

Has Char Output: N

Has Quine: N

Has self-interpreter: N

Has interpreter: N

Hello World: N

Code dependent: N

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: N

Conditional Operator: N

Turing complete: N

™

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: Y

Has self-interpreter: Y

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

P.S.: Only type 2 can do the cat program and reverse cat program. Only type 4 has a self interpreter. Only type 1-3 has input and char input.

开？关！

Computable: Y

Has Input: N

Has Output: N

Has Char Input: N

Has Char Output: N

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: Y

Textual: Y

Conditional Operator: Y

Turing complete: Y

坑

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: N

硕鼠

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: N

P.S.: Assume GBK encoding in this case.

这不是编程语言！

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

P.S.: Assume GBK encoding in this case.

🕳️

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: N

A

Anti-Machine language

Computable: N

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: Y

Has interpreter: Y

Hello World: N

Code dependent: N

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

APLWSI

Computable: Y

Has Input: N

Has Output: N

Has Char Input: N

Has Char Output: N

Has Quine: N

Has self-interpreter: Y

Has interpreter: Y

Hello World: N

Code dependent: N

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

Arithmetic

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

B

B2C

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: N

Has interpreter: U

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: N

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: N

B-H

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: U

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: Y

Turing complete: Y

Beditasm

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

Befunge

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: Y

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

Black Pentagon

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: N

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: N

Conditional Operator: Y

Turing complete: N

P.S.: Title should not be "Black Pentagon", should be an image.

Blah

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: N

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

Brainfuck

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: Y

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

Brainbits

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: U

Loops: Y

Textual: Y

Conditional Operator: Y

Turing complete: N

brainfuck

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

brainfuck

Computable: Y

Has Input: N

Has Output: N

Has Char Input: N

Has Char Output: N

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

brainfuck

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: N

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

Brainfuck extended

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: Y

Turing complete: Y

Brainloller

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: N

Conditional Operator: N

Turing complete: Y

Brainpocalypse

Computable: Y

Has Input: N

Has Output: N

Has Char Input: N

Has Char Output: N

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: Y

Textual: Y

Conditional Operator: Y

Turing complete: Y

C

C-Shop

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

Chicken

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: Y

Has self-interpreter: U

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: U

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

Compute

Computable: N

Has Input: N

Has Output: N

Has Char Input: N

Has Char Output: N

Has Quine: U

Has self-interpreter: U

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: N

D

Deadfish

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: N

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

Deadfuck

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: 6

Textual: Y

Conditional Operator: N

Turing complete: Y

DeleteScript

Computable: Y

Has Input: N

Has Output: N

Has Char Input: N

Has Char Output: N

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: N

Code dependent: N

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: U

Conditional Operator: N

Turing complete: N

P.S.: DeleteScript interpreters deletes its code no matter what its code is, so it's not code dependent. The code can be any file, either textual or non-textual, so the "Textual" property for it is U.

DFS

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

E

Eliminate

Computable: N

Has Input: N

Has Output: N

Has Char Input: N

Has Char Output: N

Has Quine: N

Has self-interpreter: N

Has interpreter: N

Hello World: N

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

EmojiWee

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

F

F!

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

Fish Code

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: U

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

flag

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: Y

Has self-interpreter: U

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: U

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: N

fuck-brain

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

H

Hello

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

Hello++

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

HQ9+

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

H🌍

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

I

Ifthen

Computable: N

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: Y

Has self-interpreter: U

Has interpreter: N

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: N

ifunge

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: N

Conditional Operator: N

Turing complete: Y

InterpretMe

Computable: Y

Has Input: Y

Has Output: N

Has Char Input: Y

Has Char Output: N

Has Quine: N

Has self-interpreter: Y

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: Y

M

Malloc

Computable: Y

Has Input: N

Has Output: N

Has Char Input: N

Has Char Output: N

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

N

Nil

Computable: Y

Has Input: N

Has Output: N

Has Char Input: N

Has Char Output: N

Has Quine: Y

Has self-interpreter: Y

Has interpreter: Y

Hello World: N

Code dependent: N

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

NNVText

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

Nope.

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: Y

Has interpreter: Y

Hello World: N

Code dependent: N

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

P

Permission denied

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: Y

Has interpreter: Y

Hello World: N

Code dependent: N

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

PlusOrMinus

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

Preserve Line Numbers

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: N

Has Quine: Y

Has self-interpreter: N

Has interpreter: Y

Hello World: N

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

P.S.: It is considered that this esolang has no char output, because it only prints line numbers

PTotE

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

R

Remove Line Numbers

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

S

Setlang

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: N

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: N

Simon says brainfuck

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

Sreg

Computable: Y

Has Input: N

Has Output: Y

Has Self-Interpreter: N

Has Interpreter: Y

Hello World: N

Cat Program: N

Reverse Cat Program: N

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

Stacks

Computable: Y

Has Input: N

Has Output: N

Has Char Input: N

Has Char Output: N

Has Quine: N

Has self-interpreter: N

Has interpreter: N

Hello World: N

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: N

Conditional Operator: Y

Turing complete: Y

StegFuck

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: N

Conditional Operator: N

Turing complete: Y

T

Text

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

Two-instruction madness!

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: Y

Has interpreter: Y

Hello world: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Conditional operator: N

Turing Complete: Y

V

VerboseFuck

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: Y

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

W

Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: Y

Turing complete: N

WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: N

Loops: Y

Textual: Y

Conditional Operator: Y

Turing complete: N

Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee with looping

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: U

Has Char Output: N

Has Quine: N

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: Y

Textual: Y

Conditional Operator: Y

Turing complete: N

Welcome to Esolang, the esoteric programming languages wiki!

Computable: Y

Has Input: N

Has Output: Y

Has Char Input: N

Has Char Output: Y

Has Quine: Y

Has self-interpreter: N

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: N

Reverse Cat Program: N

Loops: N

Textual: Y

Conditional Operator: N

Turing complete: N

wsad

Computable: Y

Has Input: Y

Has Output: Y

Has Char Input: Y

Has Char Output: Y

Has Quine: U

Has self-interpreter: U

Has interpreter: Y

Hello World: Y

Code dependent: Y

Cat Program: Y

Reverse Cat Program: Y

Loops: Y

Textual: Y

Conditional Operator: N

Turing complete: Y

Retrieved from "https://esolangs.org/w/index.php?title=Programming_abillities_of_different_esolangs&oldid=125252"