# “Hello, World!”

So... uh... this is a bit embarrassing. But we don't have a plain "Hello, World!" challenge yet (despite having 35 variants tagged with , and counting). While this is not the most interesting code golf in the common languages, finding the shortest solution in certain esolangs can be a serious challenge. For instance, to my knowledge it is not known whether the shortest possible Brainfuck solution has been found yet.

Furthermore, while all of Wikipedia (the Wikipedia entry has been deleted but there is a copy at archive.org ), esolangs and Rosetta Code have lists of "Hello, World!" programs, none of these are interested in having the shortest for each language (there is also this GitHub repository). If we want to be a significant site in the code golf community, I think we should try and create the ultimate catalogue of shortest "Hello, World!" programs (similar to how our basic quine challenge contains some of the shortest known quines in various languages). So let's do this!

## The Rules

• Each submission must be a full program.
• The program must take no input, and print Hello, World! to STDOUT (this exact byte stream, including capitalization and punctuation) plus an optional trailing newline, and nothing else.
• The program must not write anything to STDERR.
• If anyone wants to abuse this by creating a language where the empty program prints Hello, World!, then congrats, they just paved the way for a very boring answer.

Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.

• Submissions are scored in bytes, in an appropriate (pre-existing) encoding, usually (but not necessarily) UTF-8. Some languages, like Folders, are a bit tricky to score - if in doubt, please ask on Meta.
• This is not about finding the language with the shortest "Hello, World!" program. This is about finding the shortest "Hello, World!" program in every language. Therefore, I will not mark any answer as "accepted".
• If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainfuck-derivatives like Alphuck), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.

As a side note, please don't downvote boring (but valid) answers in languages where there is not much to golf - these are still useful to this question as it tries to compile a catalogue as complete as possible. However, do primarily upvote answers in languages where the authors actually had to put effort into golfing the code.

For inspiration, check the Hello World Collection.

## The Catalogue

The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.

## Language Name, N bytes


where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

## Ruby, <s>104</s> <s>101</s> 96 bytes


If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

## Perl, 43 + 2 (-p flag) = 45 bytes


You can also make the language name a link which will then show up in the snippet:

## [><>](https://esolangs.org/wiki/Fish), 121 bytes


/* Configuration */

var QUESTION_ID = 55422; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.

/* App */

return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(a) {
});
comment_page = 1;
}
});
}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(c) {
if (c.owner.user_id === OVERRIDE_USER)
});
else process();
}
});
}

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

function getAuthorName(a) {
return a.owner.display_name;
}

function process() {
var valid = [];

var body = a.body;
if(OVERRIDE_REG.test(c.body))
body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
});

var match = body.match(SCORE_REG);
if (match)
valid.push({
user: getAuthorName(a),
size: +match[2],
language: match[1],
});
else console.log(body);
});

valid.sort(function (a, b) {
var aB = a.size,
bB = b.size;
return aB - bB
});

var languages = {};
var place = 1;
var lastSize = null;
var lastPlace = 1;
valid.forEach(function (a) {
if (a.size != lastSize)
lastPlace = place;
lastSize = a.size;
++place;

.replace("{{NAME}}", a.user)
.replace("{{LANGUAGE}}", a.language)
.replace("{{SIZE}}", a.size)

var lang = a.language;
lang = jQuery('<a>'+lang+'</a>').text();

languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
});

var langs = [];
for (var lang in languages)
if (languages.hasOwnProperty(lang))
langs.push(languages[lang]);

langs.sort(function (a, b) {
if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
return 0;
});

for (var i = 0; i < langs.length; ++i)
{
var language = jQuery("#language-template").html();
var lang = langs[i];
language = language.replace("{{LANGUAGE}}", lang.lang)
.replace("{{NAME}}", lang.user)
.replace("{{SIZE}}", lang.size)
language = jQuery(language);
jQuery("#languages").append(language);
}

}
body {
text-align: left !important;
display: block !important;
}

width: 290px;
float: left;
}

#language-list {
width: 500px;
float: left;
}

font-weight: bold;
}

table td {
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div id="language-list">
<h2>Shortest Solution by Language</h2>
<table class="language-list">
<tr><td>Language</td><td>User</td><td>Score</td></tr>
<tbody id="languages">

</tbody>
</table>
</div>
<tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>

</tbody>
</table>
</div>
<table style="display: none">
</tbody>
</table>
<table style="display: none">
<tbody id="language-template">
</tbody>
</table>

• @isaacg No it doesn't. I think there would be some interesting languages where it's not obvious whether primality testing is possible. – Martin Ender Aug 28 '15 at 13:56
• If the same program, such as "Hello, World!", is the shortest in many different and unrelated languages, should it be posted separately? – aditsu quit because SE is EVIL Aug 28 '15 at 15:33
• @mbomb007 Well it's hidden by default because the three code blocks take up a lot of space. I could minify them so that they are a single line each, but I'd rather keep the code maintainable in case bugs come up. – Martin Ender Aug 28 '15 at 19:34
• @ETHproductions "Unlike our usual rules, feel free to use a language (or language version) even if it's newer than this challenge." Publishing the language and an implementation before posting it would definitely be helpful though. – Martin Ender Aug 29 '15 at 23:01
• @MartinEnder ... Almost. If two BF solutions have the same size, the one with smaller lexicographical order will take smaller number of bytes in Unary. Of course the smallest Unary solution translated to BF is guaranteed to be smallest. – user202729 May 20 '18 at 10:20

# Prolog, 23 bytes

write('Hello, World!').

• What did you use to define a string if you didn't use "? – Beta Decay Aug 28 '15 at 12:57
• @BetaDecay Nothing, strings didn't exist as far as I know. So using " to create strings would create an array of character codes (ie ascii/unicode codes) representing the string. Character codes strings is created with backquotes in SWI-Prolog now. – Fatalize Aug 28 '15 at 13:01
• You can use single quotes to turn this into an atom, and thus make the program completely portable: write('Hello, World!'). More declaratively, I would simply define a a fact like: msg('Hello, World!').. Usage example: ?- msg(M)., succeeding with M = 'Hello, World!'.. – mat Sep 1 '15 at 12:18
• @mat Good suggestion that I use atoms instead of strings. For the msg('Hello, World!') though, I don't think it's valid in this challenge because it outputs M = 'Hello, World!'. instead of just Hello, World! (granted, it also outputs true after in my answer but I assume this is acceptable because Prolog really likes to output true or false :)) – Fatalize Sep 1 '15 at 12:25
• I know, the way this challenge is formulated kind of forces you to use impure langauge elements. Too bad! (BTW: The last sentence of your post is no longer applicable.) – mat Sep 1 '15 at 12:27

# goruby, 6 bytes

h:H,:W


Apart from the method_missing override, goruby also defines Kernel#h which accepts 3 parameters: the first letter of _ello (default H), the first letter of _orld (default w), and the final character (default !).

• Nice, I didn't know about the parameters it takes :) – Lynn Sep 3 '15 at 2:00

# NULL, 91 bytes

int("8bxyd2qvpj6uq6gh9u8hlrjfwqkx8i2pvid5auhrsrbpp8gsczv6ye26ew0pkx05wem94m9zqkn8prqir",36)


This number represents a program, and it has 126 digits in decimal representation. I use base-36 here to shorten the number. It seems acceptable because the interpreter of NULL uses the python eval on the program before executing it (presumably to allow specifying the program as a product of prime numbers). The prime factorization (used while executing the program) is

3*3*3*17*31*73*127*139*151*157*167*197*239*241*307*367*367*419*479*499*
547*599*619*677*751*839*919*947*947*1019*1039*1097*1129*1217*1249*1301*
1303*1327*1433*1499*1543*1613*1709*1777*1873*1951*1993*2063


I found this program by using something like A* search. It tracks the state of the NULL interpreter and two additional values:

• print - number of characters in the Hello, World! message it managed to output so far
• length - natural logarithm of the number that represents the program

For each state, it picks 10 possible commands the language has (there are 14, but the rest are too uncomfortable to search), and calculates 10 new states. To find the shortest program, it holds the states in a priority_queue, arranged by the following cost function:

print - length / 25


If I use a fudge factor much different from 25, it either keeps searching forever (until it eats all RAM) or finds sub-optimal solutions.

BTW there is a bug in the interpreter in the generation of prime numbers. I fixed it by simplifying the code this way:

def factor_g(include_builtin_list = True):
if include_builtin_list:
for x in plist: yield x
k = plist[-1] + 2
while True:
yield k
k += 2


# Turing Machine Code, 132 bytes

As usual, I'm using the table syntax defined here.

0 * H r q
q * e r w
w * l r e
e * l r r
r * o r t
t * , r y
y * _ r u
u * W r i
i * o r o
o * r r p
p * l r a
a * d r s
s * ! r halt


If the above link isn't working (sometimes it works for me, other times the page refuses to load) you may also test this using this java implementation.

# Candy, 18 bytes + 1 = 19 bytes

Push (technically queue) string (character-by-character) onto the stack, and loop to print

"Hello, World!"(;)


The interpreter should be called with -q to suppress STDOUT messages.

• Why 3 bytes for switch? The Binary-encoded Golfical answer takes a switch and that's only a byte... – cat Dec 14 '15 at 14:23
• There was a suggestion on one of my other posts that suppressing STDOUT should have a cost, so I followed that here. But it doesn't seem to be consistently followed. – Dale Johnson Dec 14 '15 at 22:44
• The convention is typically 1 byte / switch. However, you can raise the question on Meta and get the community's opinion. – cat Dec 14 '15 at 22:56

# Rotor, 14 bytes

"Hello, World!


Nothing too fancy here. Like Pyth, quotes and most other structures are implicitly closed at EOF.

Try it online.

Check out Rotor.

# HolyC, 24 bytes

Print("Hello, World!");


Nothing special here, I just wanted to pay tribute to the lunatic who wrote TempleOS and its companion language, HolyC.

# K (oK), 20 19 bytes

!0:"Hello, World!"


Try it online!

Note that this program gets killed, which effectively prevents implicit or error output. Your shell might indicate that the program was killed, but this output is produced by the shell, not the program.

### Alternative solution, 20 bytes, clean exit

{}0:"Hello, World!"


I'm still trying to figure out why this works, but it does.

Try it online!

### Almost-solutions

• "Hello, World!" prints the string with the quotes.

•  0:"Hello, World!" prints Hello, World!"Hello, World!", the first copy explicitly, then second one implicitly.

• 00:"Hello, World!" prints the correct output to STDOUT, but the leftmost 0 is a type error and prints an error message to STDERR.

• !0:"Hello, World!" prints on

• You know you've attained master rank when you don't know why your code golf works, but it still does. – AdmBorkBork Feb 9 '17 at 20:20
• Of course. The true&tested method of "Can't possibly work, let's try it anyway." ~ Eugene van der Pijll – primo Feb 10 '17 at 11:16

# Wise, 135 + 3 = 138 bytes

~-<<<~-<<<::^~-<~-<<<~-<<~-:::^~-<<<~-^::?:>~-<~-:?::^~-<<~-<~-<<::^~-<<<<<:<::^<~-<<~-<~-<~-|!::^~-<~-<~-<<<~-<!:::^~-<<<^::^~-<<<<<~-


Try it online!

## Alice, 19 18 bytes

Thanks to Sp3000 for saving 1 byte.

"&O@!dlroW ,olleH


There should be a carriage return (0x0D) at the end of the program, but browsers don't like those. Consequently, this version is also not testable on TIO. Here is a 19-byte printable-only alternative:

"!dlroW ,olleH"d&O@


Try it online!

Finally introducing my latest language! This works like Hello, World in most Fungeoids, and doesn't really touch upon all the advanced features Alice has:

"&O@!dlroW ,olleH  Push the individual code points of the entire source code
except the " to the stack. Remember that there's a 13 at the end.
&                  Repeat the next command 13 times.
O                  Pop 13 characters from the stack and print them.
@                  Terminate the program.


In the 19-byte version, we're pushing the 13 explicitly, using the stack depth command d.

Here is a somewhat more interested 21-byte version, which makes use of Alice's main feature: by moving diagonally, Alice operates in a separate mode (called Ordinal mode), which works with strings instead of integers. However, due to the diagonal movement, it's a bit harder to follow the code:

/oH!lloo /
@""edlr,W\


Try it online!

The initial / sends the instruction pointer off southeast, where it will bounce diagonally up and down between the two lines. The \/ at the end offset the IP's position by one cell so that on the way back, the IP bounces through the other characters. So ignoring those mirrors, the code that actually gets executed is:

"Hello, World!"o@


In Ordinal mode, "Hello, World!" actually pushes an entire string to the stack, o prints that string, and then @ still terminates the program.

# Aceto, 19 bytes

Aceto is the coolest programming language because I got it as a birthday present. It is a stack based programming language that makes use of a 2D Hilbert curve grid. Here is Hello World:

o,or
l Wl
le!d
"H"p

• Golfed 16+1=17 for -l flag – drham Mar 9 '18 at 20:28

# Husk, 8 bytes

¨H◄⁰,ω]!


Try it online!

Husk got compressed strings!

A dictionary of common n-grams for n from 1 to 9 was built using a procedure based on Huffman coding, taking frequencies of n-grams from http://norvig.com/mayzner.html. All printable ASCII characters plus newline were forced to have 1-byte encodings with codes corresponding to themselves, while newlines were encoded with ¶. N-grams that occurr frequently at the start of words also have variants with title-case and with a leading space/newline; n-grams that occurr frequently at the end of words also have variants with a trailing space/newline.

Some optimizations were performed on the resulting dictionary: for instance, the 5-gram "Hello" was removed from the dictionary since it had been encoded with three bytes, while the 4-gram "ello" is encoded with two bytes, so we can simply encode "H"+"ello" for a total of 3 bytes.

After the Huffman tree was built, codes were reassigned (mantaining their length unchanged) such that the encoded words could in some way recall their respective plaintext: most compression systems ignore this and as such their results are completely obscure to the human reader, while in this case I'm sure that most of you could guess what H◄⁰,ω]! means even if it was not presented inside this challenge. In particular, ◄⁰ encodes "ello", since ◄ stands for l (left), and ⁰ looks like an o, while ω] encodes " World" since ω looks like a w and ] looks like a D (capitalization was ignored for this assignment of codes).

# Chip, 174166106 97 bytes

94 bytes for the code + 3 bytes for the flag (-w) which allows execution without input.

!ZZZZZZZZZZZZt
|))))))x)))))f
|)xx)x-))xxxa
|)))))-))x))c
)))))x-))))g
)-))))-x)xd
b e^b^e


Try it online!

Chip is a 2D language inspired by integrated circuits, input and output are broken down into individual bits which travel through gates and across wires.

Ungolfed (134 bytes):

!ZZZZZZZZZZZZt
xxxxxxxxxxxxxh
)))))xx)))))xg
x))))))x)))))f
xxxxxxx)x)xxxe
)x))))xx)x)xxd
x)))))x))x))xc
xxxx)xx)))xxxb
x)xx)xx))xxx)a


How the ungolfed version works:

This implementation encodes the target string Hello, World! as a bit matrix, somewhat reminiscent of core memory. The leftmost column of )'s and x's corresponds to H in the output, the rightmost column to !. The ) is an Or-gate (mapping to a 1 in the output), and the x is a wire crossing (mapping to a 0).

The first row is for timing, and the remaining rows are for each of the bits of the output (the row ending in h is the highest bit, and a is the lowest).

The timing behavior starts with the !. ! produces a single 1-cycle pulse at the beginning of execution. The line of Zs then control the left-to-right propagation of the signal at a rate of one element per cycle, each one corresponding to the transition between consecutive letters of the output. Each Z also sends a signal to the column below. At the end of the timing row is t, which terminates the program, preventing infinite output of null characters at the end.

In the first cycle, the first data column is powered. We see OR-gates ()) on the rows for bits d and g, turning them on; the remaining bits stay off because the wire crosses (x) won't propagate the signal from the top to the left. This gives us 01001000, which is H.

In the next cycle, only the second data column is powered. Rows a, c, f and g turn on much like the bits in the first cycle, and the remaining bits are off. This gives us 01100101, which is e.

This continues all the way across to the right, giving the remainder of the output.

Golfing it:

There's not a lot that could be done here, but there are a few things of note:

• The h row is always off, so that can be eliminated.
• Each row can be trimmed on both ends, removing unnecessary x's, so long as the timing signal can still be propagated downward to rows that need it below. This is why the rows are rearranged; to maximize the trimming that can occur.
• The construct )a is equivalent to simply a, so long as the signal did not need to be propagated downward from the OR-gate.

All other changes are just mashing things around to save single bytes.

# Windows Portable Executable (PE), 1175 bytes

By using the following Assembly code instead of C code (which inevitable imports unecessary libraries and whatnot), we can cut down the executable size from 261591 bytes (compiled C answer) to a measily 1536 bytes.

extern ExitProcess, GetStdHandle, WriteConsoleA

section .n
msg db "Hello, World!",10

; <entry point>
Start:
; GetStdHandle(in A1)
push -11           ; A1 - STD_OUTPUT_HANDLE
call GetStdHandle  ; Puts in eax

; WriteConsole(in A1, in A2, in A3, out A4, reserved A5 )
push 0             ; A5 - Don't care (reserved argument)
; A4 - Don't care ("number of chars written")
push 14            ; A3 - Length ("number of chars to write")
push msg           ; A2 - String (buffer pointer)
push eax           ; A1 - Console output handle (from GetStdHandle)
call WriteConsoleA

; ExitProcess(in A1)
push 0             ; A1 - Exit code
call ExitProcess


However, that is still way too large. So I installed HxD, a hex editor, and went on to try and remove unecessary parts.

Apparently, Windows' executables are filled with padding (hex indication) for no apparent reason. So I removed the tailing block of zeroes at the end of the file, messed around a bit, and managed to cut it down to 1175 bytes. Here's the pastebin hexdump of the executable.

Unfortunately, at my every attempt to remove the other paddings (0x1A8-0x1FF, 0x22B-0x3FF), the program would simply not run. I've been doing this for a few days to no success. Thus, I'm posting this beaten, at the still staggering 1KB of size.

I am sure this can be golfed even further, so if anyone manages to cut down the size, feel free to edit this answer or perhaps even post another one.

As a bonus, this executable also works on DOS.

• If anyone wants to try golfing this down some more, they may find this answer on SO and the material it references helpful. – 3D1T0R May 29 '18 at 19:53
• github.com/pts/pts-tinype Some smaller Hello World .exes, not mine. I couldn't get the 268-byte ones to run at all, and the 402-byte one would only run with my antivirus shut off. – Nnnes Jul 23 '18 at 11:19

# Magic Number, 174 bytes

0010000033001000010000100001080010000114001000011100100000870010000032001000004400100001110010000108001000010800100001010010000072006006006006006006006006006006006006006006


Magic Number is a simple human-writable stack-based esolang where the source code consists of a single positive integer. The decimal digits are read from most significant to least significant.

The only two commands used here are 0010xxxxxx, which pushes the non-negative integer xxxxxx onto the stack, and 006, which pops the stack and prints the character with that character code. The program pushes the numerical value of the characters in "Hello, World!" onto the stack in reverse order and prints them all. Branching is fairly expensive, so I feel this is probably optimal.

• Welcome to PPCG! – Martin Ender Aug 13 '17 at 17:35

# Pain-Flak, 152 bytes

)))))}{}{)))}{))(}{((((])][][][([(])()()([((]][[()()()(])}{][][)][(][([())(]][][][][][[))(]][[)][][)][][][][))(}{}{))))(}{)}{)}{))()()()((((((((((((}><{


This is a trivial modification of @HeebyJeebyMan's “Hello, World!” in Brain-Flak. They also discovered a slightly different solution with the same length shortly before I golfed mine down to this byte count.

Try it online!

### How it works

Pain-Flak is transpiled to Brain-Flak as follows.

• Let the Pain-Flak source code be S.
• Transliterate S, replacing all opening brackets with their closing counterparts and viceversa. Call the result T.
• Reverse S character by character. Call the result R.
• The Brain-Flak source code is T || R, where || symbolizes concatenation.

For the Pain-Flak program in this answer, transpilation yields the following Brain-Flak program.

((((({}{}((({}((){}))))[([][][])])[()()()]))[[]])()()()[({}[][]([])[])])(()[[][][][][]](()[[]]([][]([][][][]((){}{}((((){}({}({}(()()()())))))))))))
{<>}
{<>}
(((((((((((()()()()){}){}){}()))){}{}())[][][][])[][])[[]]())[[][][][][]]())([([]([])[][]{})]()()()([[]](([()()()]([([][][])](((({}()){}))){}{})))))


Newlines have been inserted for "readability". The programs works as follows.

• Line 1 pushes garbage on the first stack.

• {<>} on line 2 switches stacks until the top of the stack is non-zero.

This switches to the second stack.

• {<>} does the same. Since the top of the second stack is 0, we stay on the second stack.

• Line 4 is just @HeebyJeebyMan's “Hello, World!” in Brain-Flak, which never switches stacks and is, therefore, unaffected by the garbage on the first stack.

• You care if i use the pain-flak description for my readme? – Christopher Jan 21 '18 at 0:17
• @Christopher2EZ4RTZ Go ahead. :) – Dennis Jan 21 '18 at 0:19

# Brain-Flak, 144 138 bytes

((((((((((((()()){}){}){}){}()))){}{}())([][]){})[][])[[]]())[((()[]){}){}])([()[]](([]([](([][]([](()[][]){})))[]{}[])[[]])))(([][][]){})


Try it online!

The product of my code from the Text to Brain-Flak challenge. Beats the previous answer by 4 bytes! Wheat Wizard has since updated to beat mine by 2. And my code has produced a 140 byte solution (which I've golfed a further 2 bytes off).

Explanation coming as soon as I understand it myself...

### How It Works:

Note that Brain-Flak is a stack based language which outputs the stack on exit. This means the text has to pushed to the stack in reverse.

((((((((((((()()){}){}){}){}()))){}{}())([][]){})[][])[[]]())[((()[]){}){}])


This first part pushes "World!". This part is actually near identical to Wheat Wizard's answer, and has the same byte count.

( Pushing "W"
( "o"
( "r"
( "l"
( "d"
( "!"
(((((
(()()) Push 2
{}) Pop the 2 to push 4
{}) Pop the 4 to push 8
{}) Pop the 8 to push 16
{}()) Pop the 16 and create a 1 to push 33 ("!")
)){}{}()) Create two copies of 33 and pop them to push 99 and a 1 to push 100 ("d")
([][]) Push the stack height (2) twice to the stack
{}) Pop the 4 and push 8 + 100 = 108, ("l")
[][] Add the stack height (3) twice to the current value
) Push 108 + 3*2 = 114 ("r")
[[]]() Add negative stack height (4) and 1 to the current value
) Push 114 + (-4) + 1 = 111 ("o")
[ Subtract
(
(()[]) Push stack height (5) + 1
{}) Pop the 6 to create 12
{} Pop the 12 to create 24
]) Push 111 - 24 = 87 ("W")


This part pushes "ello, "

([()[]](([]([](([][]([](()[][]){})))[]{}[])[[]])))

( "e"
[()[]] Save negative stack height (6) and 1 for later (-7)
( "l"
( "l"
[] Save stack height (6) for later
( "o"
[] Save stack height (6) again
(( ","
[][] Save stack height (6) twice (12)
( " "
[] Save stack height (6)
(()[][]){} Push 1 + stack height (6)*2 = 13 and double it = 26
) 26 + 6 = 32 (" ")
) 32 + 12 = 44 (",")
)[]{}[] Add the stack height (9), pop the 44 and add the stack height again (8)
) 44 + 9 + 44 + 8 + 6 (saved) = 111 ("o")
[[]] Subtract stack height (9)
)) Push 111 - 9 + 6 (saved) = 108 ("l") twice
) Push 107 - 7 = 100 ("e")


And finally (([][][]){}) pushes "H" by adding the stack height (12) three times and doubling it.

# Inform 7 + C by G, 36 bytes

Include C by G.Z:say "Hello, World!"


This code requires at least version 1/150829 of the code golfing extension.

• I got rid of my old version. – Lynn Aug 29 '15 at 5:20
• Please change the language name to "Inform 7 + C by G", since you're using a library – ASCII-only Apr 20 '18 at 1:22
• @ASCII-only As the cost of the library is included I don't think that's necessary. – curiousdannii Apr 20 '18 at 1:34
• @curiousdannii nope, it's still necessary (at least for libraries that don't come with the standard distribution) – ASCII-only Apr 20 '18 at 2:48

# Whirl, 955 733 bytes

-~200 bytes using implicit modulo when output magic - I haven't checked anywhere close to all the simple possibilities, so this might be very suboptimal.

It might be possible to use memory/the operations wheel value as extra storage to make things shorter, but all approaches I've tried using those are not golfier than the naive one

1100001110010001111100110000000000000100000100000100000110000010000100100010001000000000000111110001111000111110001111000000000000011110000011100100011001111110001110011111000000000000000000000000000100100110000001111110001110011111000000000001001000100010000000000001111100000111110001001000110001000111110000011110000000000000000010001001100111111000100111110011000000000000000000000000010000011000000000110010001100010000000000011111000001111000000000000000000111110001111000111110001111000001001001100111111000111001111100000000000100100111001111110001111001111100000000000000000000000111100000111001000111001111110001111001111100000000000000000000000000000001111000001110010010001000000000000000000000000111110000011111000100100


Try it online!

1 _
: ; _ + _ + _ + _ : _ + _ : _ * _ + _ : .
+ _ + _ + _ + : - _ + _ + _ + _ - _ : . _ :
+ _ + _ + _ + _ + _ + _ + _ : . _ . _ :
+ _ + _ + _ : .
+ _ + _ + _ + : + _ : .
* _ - _ + _ + _ + _ + _ : . _
: ; _ + _ + _ + _ + _ + _ + _ : _ * _ * _ : .
* _ * _ * _ - _ + _ + _ + _ + _ + : - _ + _ : . _ :
+ _ + _ + _ : . - :
+ _ + _ + _ + _ + _ + _ - _ : . - :
+ _ + _ + _ + _ + _ + _ + _ + _ - _ : .
+ _ + _ + _ + _ + _ + _ + : + _ : .


Every command switches operation wheels, starting from the operation wheel. Note that the cost depends on the current and previous command of the wheel, which is why there are so many no-ops.

Each character is on its own line, except for the two ls in a row. Some constructs used here are:

• : ; - load the 1 from operation value into math value
• _ + - add memory to math value - this can be used for e.g. repeated additions to emulate multiplications
• _ * - square. This is used for H since 72 = 8 * 8 + 8
• : . _ - store math value to memory, output, switch back to math wheel

Lines ending with : indicate the 1 from the operation wheel is being loaded, but the math value is not being overwritten. This is useful when consecutive characters are close in character codes.

### Operation wheel commands

• 1 - set (operation) value to 1
• : - store value into memory. In this program it's always 1
• . - output chr(memory)

### Math wheel commands

• + - add memory to (math) value - this is different to operation value
• * - multiply memory with value
• - - negate value - this is the only way to subtract
• ; - load memory into value
• : - store value into memory

See the language page for descriptions of unused commands

Try it online!

• :| this is shorter than the all-caps no-punctuation one here (official website). is everyone bad at golfing or do i just have no life? also i have absolutely no clue how to contact the author – ASCII-only May 6 '18 at 5:08

Logo (programming language) - 20 bytes

PRINT [Hello, World!]


Or even more exciting version:

to helloworld
hideturtle
fd 20 left 180
fd 40 left 180
fd 20 right 90
fd 20 left 90
fd 20 left 180
fd 40 left 90
fd 20 left 90
fd 20 right 90
fd 20 right 90
fd 10 right 90
fd 20 left 90
fd 10 left 90
fd 30 left 90
fd 40 left 180
fd 40 left 90
fd 20 left 90
fd 40 left 180
fd 40 left 90
fd 40 left 90
fd 20 left 90
fd 20 left 90
fd 20 left 90
fd 60 left 90
fd 40 left 180
fd 40 left 90
fd 20 left 90
fd 20 left 180
fd 20 left 90
fd 20 left 90
fd 40 left 180
fd 40 left 90
fd 40 left 90
fd 20 left 90
fd 20 left 90
fd 20 left 90
fd 40 left 90
fd 20 right 90
fd 20 right 90
fd 5  left 90
fd 5  left 90
fd 25 left 180
fd 40 left 90
fd 40 left 90
fd 20 left 90
fd 20 left 90
fd 20 left 90
fd 20 left 90
fd 40 left 180
fd 40
end

lt 90 pu fd 200 pd rt 90 helloworld


Output:

• Welcome to PPCG! This is code golf, so you should make sure that your answer is as short as possible. I don't know Logo, but it seems the HELLO is an arbitrary identifier, so you can probably shorten it and maybe it's also possible to get rid of some of that whitespace? Also, please use the required spelling Hello, World! and include the byte count of the code in your answer so that people can easily see its score. – Martin Ender Apr 10 '18 at 15:04
• First-timer here. Cool, thanks. – Artur Kędzior Apr 10 '18 at 15:09
• Hmm. I think you should stop drawing in between letters – ASCII-only May 18 '18 at 10:02

# Flobnar, 5342 41 bytes

-12 thanks to @JoKing

!dlroW ,olleH
0
:| <\@6
g>,
0_\^> +
:
- <


Try it online! (requires the -r and -i flags)

Flobnar is an interesting 2D language vaguey similar to Jellyfish. It shares a creator and many of its instructions with Befunge.

Befunge is an "instruction-based" language, in that the functionality of most commands is encapsulated by an effect. Flobnar, on the other hand, is an "expression-based" language, in that the functionality of most commands is encapsulated by a return value. For example, the 4 term always returns 4, the > term is a tail call to the cell to the east, and the + term returns the sum of the terms to its north and south.

The relevant terms used by this program are:

• @ indicates the starting point of the program. @ evaluates the term to its west, and the result of this is the return value of the program (this is printed by default; the -r interpreter flag is needed to disable this behavior).
•   lets evaluation "pass through" (it is a tail call to the cell opposite to the direction from which it was evaluated).
• ^>v< are tail calls to the cells in the direction they point.
• Digits return themselves.
• # is like  , except that is jumps to the cell two steps away, like Befunge's # command.
• \ evaluates the cell to the south to get an argument, then lets evaluation pass through to the other side with the new argument. After evaluation is finished, the original argument is restored.
• : returns the current argument.
• + returns the sum of the cells to the north and south.
• - returns the difference of the cell to the north and the cell to the south.
• ! evaluates the cell on the other side, and returns 1 if it is 0 and 0 otherwise.
• g evaluates the cell to the north to get an x-coordinate, the cell to the south to get a y-coordinate, and returns the Unicode codepoint of the cell at those coordinates.
• | evaluates the cell on the other side. If the result is 0, it returns the cell to the south; otherwise, it returns the cell to the north.
• _ evaluates the cell on the other side. If the result is 0, it returns the cell to the west; otherwise, it returns the cell to the east.
• , evaluates the cell on the other side to get a codepoint and outputs the Unicode character with that codepoint. It always returns 0. This is one of the few non-referentially-transparent operations in the language.
• This program evaluates the invalid term l. This would be an error, but -i will cause invalid characters to be ignored (treated as  ).

This program defines a recursive function that takes a single argument x and always returns 0. It looks something like this in Python:

def f(x):
if x:
print(playfield[x, 0])
return f(x - 1)
else:
print(playfield[x, 0])
return 0

• A fascinating language. It took me a bit to figure out how to do basic looping, so I tried a get/put approach and only got it down to 58 bytes. Well done! – Jo King Aug 7 '18 at 5:08
• 46 bytes – Jo King Aug 7 '18 at 5:24
• @JoKing Nice! Very clever usage of the !. I hadn't thought of the use of _ as another way to discard the result of ,. – Esolanging Fruit Aug 7 '18 at 7:07
• @JoKing I managed to get down to 45 bytes through some fairly drastic rearrangement of the code. The bytes needed to compute the 12 bother me, though -- maybe you can see something I didn't? – Esolanging Fruit Aug 7 '18 at 7:12
• All I could get was a different 45er – Jo King Aug 7 '18 at 7:33

# whenyouaccidentallylose100endorsementsinnationstates -  900  761  728  552  260 bytes

20280782166
114
fff#dff#dfffff#dfffffffffff#dfffffffffffffff#dffffffffffffffffffffffffffffffffff#dfffffffff#dfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff#dffffffffffffffffffffffffff#dfffffffffffffffffff#dffff#dffffffffff#dfffffffffff#d


Try it online!

Golfed down to 761 bytes by increasing the brute-forcer to seeds up to 9999, instead of 999

Golfed down to 728 bytes by increasing the brute-forcer to seeds up to 99999, instead of 9999

Golfed down to 552 bytes by increasing the brute-forcer to seeds up to 999999, instead of 99999

Golfed down to 260 bytes with the help of @ASCII_only

• I'm very curious as to what the inspiration for this languages name is. – Gabriel Mills Feb 6 '19 at 2:38
• @GabrielMills Explained here to Dennis – MilkyWay90 Feb 6 '19 at 2:42

# C++ (gcc), 40 bytes

main(){__builtin_puts("Hello, World!");}


Try it online!

Using builtins are shorter since #include takes up a lot of bytes. I believe this solution is optimal.

• "Optimal?" A bold claim. Ken Thompson: "Last year I taught at University of Sydney I gave that to my class, the shortest self-reproducing program in C, and I got a surprise. I didn't think there was a surprise there to be had. But, I got somebody who has the shortest one I've ever seen, which is a record breaker, by about four characters of what I had proved to myself was the shortest program, and they did it by a totally different mechanism which of course nullified the proof." princeton.edu/~hos/mike/transcripts/thompson.htm – roblogic Aug 27 '19 at 1:53

# Jasmin, 251219 165 bytes

Jasmin is an assembler for the Java Virtual Machine. It takes ASCII descriptions of Java classes, written in a simple assembler-like syntax using the Java Virtual Machine instruction set. It converts them into binary Java class files, suitable for loading by a Java runtime system.

.class H
.super sun/misc/MessageUtils
.method public static main([Ljava/lang/String;)V
ldc "Hello, World!"
invokestatic H/out(Ljava/lang/String;)V
return
.end method


Compile with java -jar jasmin.jar H.j. Execute byte code with java H.

This program is based off the "Hello, World!" program by pearce at SJSU. Golfing mainly entailed removing comments and unnecessary white space (this was true four years ago but, I have since made substantial changes). Something interesting I noted while golfing it is that a class file doesn't have to include a constructor. When a normal Java program doesn't have a constructor, a default is provided but. When there is no constructor in Jasmin, the resulting class file doesn't have one either. This would probably result in issues when trying to instantiate the class but, for the purpose of executing the main method, it works fine.

# 4 Years Later Golfs

1. I found out about the static method sun.misc.MessageUtils.out from this answer. Using this instead of System.out.print saves quite a few bytes because calling instance methods is rather expensive in Jasmin.
2. Extending sun.misc.MessageUtils saves even more bytes on that invokestatic because I can write H instead of the fully qualified class name. Omitting the .super line is not an option in Jasmin so, the other option would be extending a class with a short fully qualified name (e.g. java/io/File.

# Non-competing golfs

1. You can omit return if you invoke the class with java -noverify. This causes the JVM to segfault after printing "Hello, Word!". (-7 bytes)

2. I think I should be able to use a static initializer instead of a main method if I execute the class file with Java6 but, I can't get this to work. It would be done by replacing the header for main with .method public static <clinit>()V.(potentially -15 bytes)

}ro
"""
l,H
d e
!Wl
"ol


Try it online!

This is about as compressed as it is possible to get. The } instruction is the put instruction, but it doesn't really matter what it does since we're just using it to execute the three of the instructions below it, all of which are ".

First we execute the left, which wraps around to be the rightmost column, printing Hello. Then right (which is the center column), printing , Wor. Finally directly below in the left column, we print ld!, terminating the string literal early rather than wrapping, to avoid printing the } as well.

# unc, 38 bytes

ZNVa[]<<chgf[L'uRYYb~ JbeYQ#']:if 5:>>


# LOLCODE, 22 bytes

VISIBLE"Hello, World!"


Works in interpreters that don't require the presence of HAI and KTHXBYE.

• Agh! Posted a minute before me :P – Kade Aug 28 '15 at 13:57
• @Shebang Gotta go fast! – Fatalize Aug 28 '15 at 13:57
• damn I'm a few days to late :( – Alex Carlsen Sep 1 '15 at 11:54
• And I pronounce this code, Ungolfable! – Erik the Outgolfer Jun 4 '16 at 13:01

# Scala, 22 bytes

print("Hello, World!")


scala can run "scala scripts" which are not full program. you can save the above to a file and execute in the shell scala file.scala, and it will execute (shortcut without saving a file: scala -e 'print("Hello, World!")').

a full ordinary scala program that prints hello world:

object H extends App{print("Hello, World!")}


# Nim, 20 19 bytes

echo"Hello, World!"


Saved one byte thanks to sp3000!

• You can drop the space in between for the first one, I think :) – Sp3000 Aug 28 '15 at 15:09
• Indeed, saved me one byte! – kvill Aug 28 '15 at 15:18

# Emily, 22 bytes

println"Hello, World!"
`

This is a nice little language I stumbled upon recently.