nyuuzyou/wikis huggingface dataset:
Hello++

Hello++ or Hello Plus Plus is an improvement to the Hello programming language, created by Propeng on Sunday, the 14th of March, 2010 at about 6 PM GMT.
Hello++ will print out "Hello World" whenever it encounters 'h' or 'H'. It ignores all other characters silently.
==Quine==
Unlike the original Hello, it is possible to produce a Quine using Hello++.
 Hello World
==Compiler==
There is a Hello++ compiler in C# here.
==Interpreter==
And you can't forget Zayne's interpreter. It's an improved version of his Hello interpreter
 i = input("Enter Command: ") 
 if i != 'h':
 	if i != 'H':
 		print("")
 	if i == 'H': 
 		print("Hello World")
 else:
 	print("Hello World")
And also, you can't forget User:A's interpreter. It is written in C:
 #include <stdio.h>
 int main()
 {
 char i;
 i=getchar();
 if(i=='h'||i=='H')printf("Hello World");
 return 0;
 }
Also, modified Python interpreter:
 i=input(">")
 if i=='h' or i=='H':
 print("Hello World")
User:Cortex's interpreter written in ProcessingJS:
 var hello = function(x) {
 for(var i = 0; i < x.length; i++) {
 if (x.charAt(i) === "h" || x.charAt(i) === "H") {
 println("Hello World");
 }
 }
 };
Oh, here's a codegolfed Python 3 interpreter by Spexty (49 bytes):
 i=input()
 if i=='h'or i=='H':print('Hello World')
code golfed Python 3 implementation by User:Ractangle (46 bytes):
 print("Hello World")if input()in"h""H"else ...
Here's the same thing for Python 2, except now you have to put quotes around the input (47 bytes):
 i=input()
 if i=='h'or i=='H':print'Hello World'
Again Python 2, but this time you don't have to put quotes around the input (51 bytes):
 i=raw_input()
 if i=='h'or i=='H':print'Hello World'
Here's a shorter one for Python 3 by User:PythonshellDebugwindow (38 bytes):
 if input()in 'Hh':print('Hello World')
Here is /// version of Hello++ writen by ChuckEsoteric08
 /!/#//#/Hello World /!
This Uses ! as a program. This interpreter is uses # instead of H.
This interpreter in Gray Snail only works if the input is "h" or "H", so it can't make quines.
 INPUT ?
 GOTO is_h H [?]
 GOTO is_h h [?]
 OUTPUT "Error"
 GOTO end a a
 is_h
 OUTPUT "Hello World"
 end
Meanwhile, this one works if the input is "Hello world", so it can make quines.
 INPUT start
 POP ? start [start]
 GOTO is_h h [?]
 GOTO is_h H [?]
 OUTPUT "Error"
 GOTO end a a
 is_h
 OUTPUT "Hello World"
 end
It is interpreter in REALScript:
 new a new b input #a !label run letter b #a if #b H say if #b h say goto run !label say print Hello_World goto run
Here is a code-golfed interpreter written in ProcessingJS by user User:Harumafuji Kohei:
 function hello(x) {
 for(var i in x)
 if (x[i].toLowerCase() === 'h')
 println("Hello World");
 }
==See Also==
* Hello
* Hello, world!
* Hello++++
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Languages
Category:2010
Hello++++

Hello++++ is a simple programming language, which has one command:
* Hello World prints "Hello World".
Hello++++ is fully Non-Turing-complete, that's why programmers love it! Hello++++ is also easy to learn.
Hello++++ is based on Hello++ which is based on Hello. Hello++++ is different from Hello++ because it interprets the program like input, which makes it able to create a cat-program. However, it has a longer command for "Hello World", making the code for it longer than in Hello++ and Hello, which makes it worse for code golf competitions.
== Examples ==
===Hello World===
The "Hello World"-program is written
 Hello World
===Quine===
The Quine-program is simply written
 Hello World
(because it prints itself)
===Cat===
The Cat-program is simply written
 Hello World
(because Hello++++ uses the program as input)
== Turing completeness ==
Nope.
== Interpreters ==
One of the shortest interpreters for Hello++++ is the echo command, which comes in the package on all Linux systems. EDIT: Works on Windows too!
 $ echo Hello World
 Hello World
And of course Zayne has to make an interpreter for it!
 i = input("Enter Command: ") 
 if i != 'Hello World':
 	print("")
 else:
 	print("Hello World")
And of course User:A can make another interpreter for it!!
 i=input(">")
 print(i)
And of course User:Not Applicable can make another interpreter for it aswell! This one works in bash.
 #!/bin/bash
 read PROGRAM
 if \[ "$PROGRAM" = "Hello, World!" \]; then echo $PROGRAM
 fi
User:ChuckEsoteric08 made a shortest interpreter! This works in ///
 Hello World
User:SpaceByte's Batch Interpreter!11!!1
(@echo off and pause/pause>nul are optional. You could remove them and run it through cmd.)
set /p echo=
echo Hello World
pause>nul
And User:None1's Powershell interpreter!
 if((read-host)-eq"Hello World"){write-host "Hello World"}
User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff's HQ9+ interpreter
 h
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Category:Languages
Category:Total
Category:Output only
Category:Pseudonatural
Hello++++++++

Hello++++++++ is a joke language by User:SpaceByte, to parody Hello++++, and the prior languages.
==Commands==
Prior derivatives of Hello, and it itself use h, H, or "Hello World" (or something similar), as the only command. However, Hello++++++++ is adaptive.
Your input is always the result. Therefore, a Cat, Quine, and Hello_World program can all be written one way. With this capability, you can say hi in ways never seen before in Hello, you can even say bye!
Hello, World!
(or similar).
Unlike Hello++++, it is also backwards compatible. 'H' and 'h' programs are backwards compatible aswell.
== Interpreters ==
The first interpreter was made in C# by User:SpaceByte:
using System;
					
public class Program
{
	public static void Main()
	{
		Console.WriteLine("welcome to the exquisite Hello++++++++ ide.");
		Console.WriteLine("gib code");
		string input = Console.ReadLine();
		
		string build = "";
		for (int i = input.Length; i > 0; i--) {
		 build += "h";
		}
 		
		if (input.ToLower() == build) {
		 foreach (char c in input) {
		 Console.WriteLine("Hello World");
		 }
		} else {
		 Console.WriteLine("\n" + input);
		}
		Console.WriteLine("\nProgram Ended!\n\n");
		Main();
	}
}
The second interpreter was made in Python by User:None1:
 a=input()
 if a.lower()=='h'*len(a):
 print('\n'.join(['Hello World']*len(a))
 else:
 print(a)
Category:Output_only
Category:Joke_languages
Category:Languages
Category:2023
Category:Total
Category:Implemented
Category:Unusable for programming
Hello++++++++++++++++

Hello++++++++ is a joke language by User:Yes, made after User:SpaceByte challenged User:Yes to adapt Hello++++++++ and make this.
It is based on Hello++++++++ which is based on Hello++++ which is based on Hello++ which is based on Hello.
== Commands ==
It is backwards compatible with all Hello languages.
h - Print "Hello World"
H - Equivalent to h
"Hello World" - Equivalent to h
[ any input ] - Print the input
hw - Equivalent to h
wh - Print "dlroW olleH"
HELLO - Start program
GOODBYE - End program
== Interpeter ==
Conversion to Python 3:
Make sure to put
def main():
before this.
[tab] means to press the 'tab' (↹) key, and [newline] means to press the 'enter' or 'return' key (↵)
h - [tab]print("Hello World")
H - [tab]print("Hello World")
"Hello World" - [tab]print("Hello World")
[ any input ] - [tab]x = input()[newline][tab]print(x)
hw - [tab]print("Hello World")
wh - [tab]print("dlroW olleH")
HELLO - main()
GOODBYE - [tab]exit()
== Conclusion ==
Just wait for Hello++++++++++++++++++++++++++++++++++++..
Category:Output_only
Category:Joke_languages
Category:Languages
Category:2023
Category:Total
Category:Implemented
Category:Unusable for programming
Hello, golf!

Hello, golf! is a language made by User:A casual user. It is supposedly made to be "especially for code golfing hello world programs." Regardless of the program, the interpreter prints "hello, world!". This means that you can write a hello, world program in 0 bytes.
==Hello, world!==
 -
==See also==
* b̶r̶a̶i̶n̶f̶u̶c̶k̶, the exact same thing.
Category:Golfing language
Category:Joke languages
Category:Languages
Category:Total
Category:Unusable for programming
Category:Output only
Category:Implemented
Category:Zero-dimensional
Category:No-code esolang
Hello, world!

A "Hello, world!" program is a trivial program which outputs a static string of textIf the static string is not a variant of "Hello world", then the problem may be more often called a "Kolmogorov complexity" problem., usually
 Hello, world!
This program is often the first one written in a new esoteric programming language, to demonstrate output. It is a popular problem.
The program comes from the first example program in the classic K&R C manual. Note that the K&R version was in all lowercase and lacked an exclamation mark.
==See also==
* Hello world program in esoteric languages, a list of hello world programs in different esoteric languages
* Hello, a joke language
* HQ9+, another joke language
* HelloWorld
* H🌍
==Notes==
==External resources==
* The Hello World Collection, a collection of 490+ Hello World programs
* Hello World article on Wikipedia
* Hello world on Rosetta Code
* Hello World article on NicoNico Daihyakka
Category: Program forms
HelloWorld

HelloWorld is a language in progress by Splat. HelloWorld (or HW)'s command set consists only of the letters h,e,l,l,o,w,o,r,l,d. It must be made clear from the start that you will not be able to write the ubiquitous Hello, world! program in HW, because it's boring.
== Example ==
The following code computes 1+1 and then prints the answer.
 HELLO
 drh(01+01)
 hrl(drh)
 WORLD
The HELLO keyword denotes the program entry point. WORLD, as you would imagine, denotes the program end.
drh is a built in function that takes any maths problem as its arguments. It then stores them in memory until they are recalled. If used as a variable, returns the most recent result.
hrl, as you could probably already tell, prints its arguments.
== Compiler ==
A HW compiler was supposedly being worked on since 2005 but is most definitely abandoned by now. The current HW compiler is under work by 𝕾𝖆𝖓𝖘𝖈𝖎𝖈𝖔𝖓𝖉𝖔𝖘.
==Interpreter==
The only known implementation for HelloWorld is written in C and is available at Github. drh does not allow parentheses, and follows BEDMAS (more specifically DMAS). Additionally, only numbers can be output using hrl.
Category:Languages Category:Implemented Category:Usability unknown Category:2007 Category:Unknown computational class
Hello Fuck!

Hello Fuck! is a brainfuck derivative by User:None1.
==Memory Model==
Hello Fuck! works on a string tape and a pointer initially pointing to the first cell. But every cell in the tape can only be two kinds of string: Hello and World. Initially, all the cells are Hello.
==Commands==
It has these commands:
 Commands in Hello Fuck!
Command	Meaning
* 	Negates current cell (if the current cell is Hello then set it to World, and vice versa)
< 	Moves the pointer to the left
> 	Moves the pointer to the right
, 	Input a string and stores it into current cell, if the string isn't Hello or World then do nothing
. 	Output current cell value followed by a space
[ 	If the current cell value is Hello, then jump to the matching ]
] 	If the current cell value is World, then jump to the matching [
And like brainfuck, other characters are NOPs.
==Example Programs==
===Hello World===
 .*.
===Cat Program (sort of)===
 *[>,.<]
It never terminates, but only echoes Hello and World in the input correctly (if the input has other strings other than, Hello and World, it might print either Hello or World).
===Truth Machine (sort of)===
 ,[.].
You use Hello for 0 and World for 1.
==Computational Class==
It's the same as brainfuck with bit cells, but Hello for 0 and World for 1, so it's probably Turing complete.
==Interpreter==
Original C++ implementation (input strings can be separated by any kind of whitespace):
#include<iostream>
#include<string>
#include<cstdio>
using namespace std;
int tape[1000000];
string table[2]={"Hello","World"};
signed main(){
	string code="";
	char c;
	while((c=getchar())!=EOF) code+=c;
	int ip=0,p=0;
	while(ip':{
				p++;
				break;
			}
			case '<':{
				p--;
				break;
			}
			case ',':{
				string s;
				cin>>s;
				if(s=="Hello") tape[p]=0;
				if(s=="World") tape[p]=1;
				break;
			}
			case '.':{
				cout<
Here is the same interpreter compiled as a Windows executable.
Category:Languages
Category:Joke languages
Category:Implemented
Category:Unusable for programming
Category:Turing complete
Hello Plus Plus/Compiler

To compile using the Mono compiler, use mcs filename.cs.
<nowiki>
using System;
using System.IO;
using System.CodeDom.Compiler;
namespace HelloPP
{
	class MainClass
	{
		public static string GenerateCode (string output)
		{
			return @"
using System;
namespace HelloPP
{
	class MainClass
	{
		public static void Main ()
		{
			Console.Write(@" + "\"" + output + "\"" + @");
		}
	}
}
";
		} // public static string GenerateCode
		
		public static void Main (string[] args)
		{
			string sourceFilename = string.Empty;
			string outputFilename = string.Empty;
			
			if (args.Length != 1 && args.Length != 2) {
				Console.WriteLine("Hello++ .NET Compiler by Propeng");
				Console.WriteLine("Usage: {0} <source> [destination]",
					Path.GetFileName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName));
				Environment.Exit(1);
			}
			
			if (args.Length == 1) {
				sourceFilename = args[0];
				outputFilename = "a.out";
			} else if (args.Length == 2) {
				sourceFilename = args[0];
				outputFilename = args[1];
			}
			
			if (Directory.Exists(sourceFilename)) {
				Console.WriteLine("{0}: Is a directory", sourceFilename);
				Environment.Exit(1);
			} else if (Directory.Exists(outputFilename)) {
				Console.WriteLine("{0}: Is a directory", outputFilename);
				Environment.Exit(1);
			}
			
			StreamReader reader;
			
			try {
				reader = new StreamReader(sourceFilename);
				
				char[] chars = reader.ReadToEnd().ToCharArray();
				string output = string.Empty;
				
				foreach (char sourceChar in chars) {
					if (sourceChar.ToString().ToLower() == "h")
						output += "Hello World" + Environment.NewLine;
				}
				
				System.CodeDom.Compiler.CompilerParameters parameters = new CompilerParameters();
				parameters.GenerateExecutable = true;
				parameters.GenerateInMemory = false;
				parameters.OutputAssembly = outputFilename;
				
				try {
					CodeDomProvider codeProvider = CodeDomProvider.CreateProvider("C#");
					CompilerResults results =
						codeProvider.CompileAssemblyFromSource(parameters, GenerateCode(output));
					
					foreach(CompilerError error in results.Errors) {
						Console.WriteLine(error.Line + ": " + error.ErrorNumber + " " + error.ErrorText);
					}
				} catch (Exception e) {
					Console.WriteLine("{0}: {1}", outputFilename, e.Message);
					Environment.Exit(1);
				}
			} catch (FileNotFoundException) {
				Console.WriteLine("{0}: No such file or directory", sourceFilename);
				Environment.Exit(1);
			} catch (IOException ioe) {
				Console.WriteLine("{0}: I/O Error", sourceFilename);
				Console.WriteLine(ioe.StackTrace);
				Environment.Exit(2);
			} catch (Exception une) {
				Console.WriteLine("{0}: {1}", sourceFilename, une.Message);
				Console.WriteLine(une.StackTrace);
				Environment.Exit(2);
			}
		} // public static void Main
	} // class MainClass
} // namespace HelloPP
</nowiki>
Category:Implementations
Hello today I am a unicorn

Hello today I am a unicorn is a Turing-complete programming language that has only two variables.
== Overview ==
There are only two variables: x and y. Both are non-negative integers of unlimited size.
Source code consists of zero or more instructions. Any instruction can be prefixed by a label.
Each instruction begins with the variable name it uses (x or y), then operator that is applied and operands.
=== Operator Xor ===
Denoted by ~. No operands. Inverts the lowest bit of the variable. Example:
 x~
Value of x before: 123
Value of x after: 122
=== Operator Shift left ===
Denoted by +. No operands. Performs binary shift to the left. Example:
 y+
Value of y before: 5
Value of y after: 10
=== Operator Shift right ===
Denoted by -. No operands. Performs binary shift to the right. Example:
 x-
Value of x before: 15
Value of x after: 7
=== Operator If ===
Denoted by ?. Two operands (and they are labels). If the lowest bit is 1 jump to the first label, otherwise jump to the second label. Example:
 y? label1 label2
 label1: x+
 label2: x-
If y is odd, x will be shifted left and then shifted right. If y is even, x will only be shifted right.
Note: all instructions except this simply increment instruction pointer.
== I/O format ==
Input is a non-negative number. It is written in the x variable before program starts, while y is initially 0. When program terminates, y contains the output.
== Examples ==
=== Cat ===
Note: assuming the same I/O format as described here for converting from/to ASCII strings.
 x? copy exit
 copy: x- y+ y~ y+
 x? flip next
 flip: y~
 next: x- x? copy exit
 exit: x~
== Computational class ==
The variables x and y effectively implement two stacks of bits; you can push to these via a left-shift (possibly followed by an xor), pop them via a right-shift, and test the bottom bit via the if operator. Because the language also allows arbitrary control flow, this allows two-stack machines to be implemented more or less directly (a two-counter machine can also be implemented via treating the counter as a stack of multiple 0 bits above a single 1 bit), making the language Turing complete.
== Interpreters ==
Interpreter
Category:Languages
Category:Turing complete
Category:Implemented
Category:2020
Hello world program in esoteric languages

Due to its size, the list of hello world programs has been split into multiple parts:
* Hello world program in esoteric languages (nonalphabetic and A)
* Hello world program in esoteric languages (B-C)
* Hello world program in esoteric languages (D-G)
* Hello world program in esoteric languages (H-M)
* Hello world program in esoteric languages (N-S)
* Hello world program in esoteric languages (T-Z)
For other languages (esoteric and non-esoteric), see the Hello world page on Rosetta Code and the Hello, World page on Code golf Stack Exchange and the Hello World collection.
Category:Examples
Help, WarDoq!

Help, WarDoq! is an esoteric programming language created by Programming Puzzles & Code Golf user Dennis.
It was designed to address the plentiful shortcomings of Hello et al., which makes them unusable for code golf competitions.
While not Turing complete, Help, WarDoq! is capable of performing basic mathematical operations such as addition and primality testing.
==Language Overview==
Help, WarDoq! has 23 basic commands:
Command	Description
H 	Print Hello, World!.
h 	Print Hello, World.
E 	Print Hello, world!.
e 	Print Hello, world.
L 	Print Hello World!.
l 	Print Hello World.
O 	Print Hello world!.
o 	Print Hello world.
W 	Print hello, World!.
w 	Print hello, World.
R 	Print hello, world!.
r 	Print hello, world.
D 	Print hello World!.
d 	Print hello World.
, 	Print hello world!.
! 	Print hello world.
A 	Read two whitespace separated integers from input. Output their sum.
a 	Read two whitespace separated integers from input. Output their binary sum without carry (XOR).
P 	Read a whitespace separated integer from input. Output 1 if it is a positive prime and 0 otherwise.
p 	Read a whitespace separated integer from input. Output 1 if it is a positive or negative prime and 0 otherwise.
Q 	Print the program's source code.
q 	Print the program's reversed source code.
(space)	Begin a comment. The next non-space character ends the comment and is interpreted as usual.
All other characters are ignored.
The source code is executed character by character. The outputs of all individual commands are separated by single linefeeds.
==Implementation==
The following in a reference implementation in CJam, to be used with the official Java interpreter:
 ea0=:Q{"HhEeLlOoWwRrDd,!AaPpQq"Q|["Hh""ello"a[',L]Sa"Ww""orld"a['!L]]:m*:`[{riri+}{riri^}{rimp}{rizmp}Q`QW%`L]+er:~N*}:H~
It reads the program's source code as a single command-line argument and the program's input from STDIN.
Due to technical limitations, this online interpreter reads the source code from the first line and the input from the subsequent lines.
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Category:2015
Help.

This language is created by User:WhyNot?. Based off Assembly.
== Syntax ==
There are infinite memory slots, which each can hold 1 byte of information. When using the variable, use $. (The addresses start at 0) Note! All numbers must be in hexadecimal.
 ; Comment
 add (first number) (second number) (where to store answer) ; adds numbers
 sub ; add, but subtraction
 mul ; add, but multiplication
 div ; add, but division
 mod ; add, but modulus
 jmp (line to jump) ; jumps to line (first line is line 0)
 rnd (start of range) (end of range) (where to store answer) ; random number
 if_ (memory address) ; if 0, skip next line.
 out (Ascii of letter(s)) ; Output
 inp (one for single letter, mny for multiple) (Memory address) ; When doing a multiple letter input, each letter is stored in the following 
 ; memory after the first letter.
 boo (where to store answer) (boolean operator) (first number) (second number if required) ; Boolean
 ; Boolean operators: not, and, or_ 
 end ; ends program
 set (where to store answer) (number) ; sets variable
== Larger Variables ==
When wanting to use variables larger than 1 byte, put a number in front of the $. Then, the computer will use 1 memory cell plus the number of cells. Example:
 1$1 ; 2 bytes, uses memory space 1 and 2
== Cat ==
 inp one $0
 out $0
 jmp 0
== Hello world ==
 out 48 65 6c 6c 6f 20 57 6f 72 6c 64 21
== Truth Machine ==
 inp one $0
 sub $0 30 $0
 if_ $0
 jmp 6
 out 30
 end
 out 31
 jmp 6
Category:Languages