# “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

# evil, 62 58 bytes

no I haven't read through the over 500 other answers to make sure I'm adding something new
Found via computer search within a restricted subset of evil.

aeeaeayekeulaaaweevuewpuuuwwlweaaewguwuewpaaawaaawpweeawgw


Uses the instructions:

a increment the accumulator
u decrement the accumulator
z accumulator = 0
e weave operator (bitwise 01234567 to 20416375 on the accumulator)
w write character
k set the first pental cell to the accumulator
g set the accumulator to the first pental cell
v swap the accumulator and the first pental cell
y set the first wheel cell to the accumulator
l set the accumulator to the first wheel cell
p swap the accumulator and the first wheel cell


The pental is a thingy that stores 5 bytes and can be rotated; I don't rotate it though. The wheel is a circular list that starts at 1 element; I don't add/remove to/from it.

Try it online!

# APL, 17 bytes

⎕←'Hello, World!'


This is the portable way of printing from a full program.

In the ngn/apl demo, you can omit the ⎕← for 15 bytes.

# Pascal, 32 bytes

begin write('Hello, World!')end.


# Beatnik, 148 Bytes

It could probably be done better, but this is one of the first times I used a stack based language.

Beatnik determines commands and values based in the scrabble score for the words, but it (thankfully) doesn't check them against a dictionary.

K QQQQQQQG ZD XO K QQJA KD ZD XO K KG KD ZD ZD ZD XO XO K B KD ZD XO K QQQQF ZD ZD XO K QQQD XO K A Z KD XO ZD XO K B KD XO ZD XO K J Z XO K QQQB XO


Python interpreter can be found here

A breakdown of what I've done

K QQQQQQQG  # push 72         72
ZD          # duplicate       72 72
XO          # output H        72
K QQJA      # push 29         29 72
ZD          # duplicate       101 101
XO          # output e        101
K KG        # push 7          7 101
ZD          # duplicate       108 108
ZD          # duplicate       108 108 108
ZD          # duplicate       108 108 108 108
XO          # output l        108 108 108
XO          # output l        108 108
K B         # push 3          3 108 108
ZD          # duplicate       111 111 108
XO          # output o        111 108
K QQQQF     # push 44         44 111 108
ZD          # duplicate       44 44 111 108
ZD          # duplicate       44 44 44 111 108
XO          # output ,        44 44 111 108
K QQQD      # push 32         32 44 44 111 108
XO          # output <space>  44 44 111 108
K A         # push 1          1 44 44 111 108
Z           # subtract        43 44 111 108
KD          # add             87 111 108
XO          # output W        111 108
ZD          # duplicate       111 111 108
XO          # output o        111 108
K B         # push 3          3 111 108
XO          # output r        108
ZD          # duplicate       108 108
XO          # output l        108
K J         # push 8          8 108
Z           # subtract        100
XO          # output d
K QQQB      # push 33         33
XO          # output

• Can you add Scrabble scores to the explanation? – CalculatorFeline Jun 5 '17 at 4:34
• The version using valid scrabble words is only 100 bytes longer. – pppery Aug 2 '17 at 0:44

# C++, 48 bytes

(must be compiled with g++)

puts is slightly more concise than std::cout, shaving 6 bytes off of the other c++ answer.

#include<cstdio>
main(){puts("Hello, World!");}

• With g++, you can eliminate the space on line 1 and the int on line 2. – Dennis Aug 29 '15 at 3:56
• @Dennis, done. I think this is the shortest possible in C++. – James Aug 29 '15 at 7:02
• This is not legal C++ code. The return type of main must be int and cannot be empty. – Hubi Aug 31 '15 at 9:34
• @DJMcMayhem The fact, that compiler compiles something, does not mean, that it is correct. C++ does not support default int. – Zereges Oct 25 '15 at 11:20
• It's 47 bytes, not 48 – ASCII-only Aug 18 '17 at 12:14

## Mascarpone, 29 bytes

[!dlroW ,olleH]$.............  The esolangs page notes that from a typical programmer's point of view, it is not obvious how to program in it In fact, although the language's designer believes it to be Turing complete, and I personally respect his expertise in esoteric languages enough to take it on trust that it's at the very least a non-trivial language, I haven't figured out how to write a loop. So what this does is to push the characters [!dlroW ,olleH] onto the stack (the [] delimiters are necessary, and do for some reason end up on the stack too), pop the ] with $, and then print everything except the [, one character at a time.

• I know this is way late, but you can loop by having an operation call itself [!dlroW ,olleH]$[/.:!]v*:! – BlackCap Jul 21 '17 at 14:57 # Shtriped, 199 bytes e n e b i b + x y + i x d y + + d x 0 + b b b 1 + b n n 0 A 1 0 B 0 1 1 1 1 A 0 0 B 1 1 A 0 A 0 0 B 1 A 0 B A 0 B 1 A A A 0 0 B A A 1 A B A A 1 1 1 A A B 1 A B 1 A A 1 A A A 1 A B s n  (Tested in v1.0.0. Does not output trailing newline.) Shtriped has no strings, only non-negative arbitrary precision integers. But you can print strings by encoding them as integers. The integer that encodes Hello, World is 46758282851806618588827407. Every two digits essentially encodes one character in offset ASCII order, 82 is l, 85 is o, etc. The program basically declares the variable n to 0, and increments it one by one until it is 46758282851806618588827407, then prints it as a string. (In Shtriped, any integer larger than 0 needs to be incremented one by one to get there.) Incrementing that high is obviously impossible in any reasonable amount of time, (a 3Ghz processor could maybe do it in 500 million years) so don't run this program, you will never see it finish! However, I am certain that it would finish, it if had the time. It should never run out of memory or have a stack overflow thanks to tail recursion optimization. To explain what's really happening, here's a nearly identical program that will finish in a few seconds, outputting Hel. Everything is the same except the large column of 01AB's above the last line. e n \ declare n to 0, this is the variable that will be incremented to that huge number e b \ declare b to 0, this is the binary place value that will keep getting doubled i b \ increment b, making it 1 + x y \ define a function called "+" that returns x + y + \ define a nested function also called "+" i x \ increment x d y \ decrement y unless y is 0, in that case return the last statement's value + \ recursively call self + \ call nested "+" d x \ decrement (and return) x, since we will have over counted by 1 0 \ define a function called "0" that adds b to itself, doubling it + b b b 1 \ define a function called "1" that adds b to n, then calls 0 + b n n 0 \ at this point we could set n to be any number by calling 0 and 1 \ according to the desired number's reversed binary representation \ but these A and B helper functions help golf that part A \ calls 1 then 0 1 0 B \ calls 0 then 1 0 1 \ call functions 0 1 A B to increment n to the desired number B 1 1 1 1 A 0 A 0 0 A B 1 1 \ expanding the B's and A's, this becomes 0111111001000100111 \ which reverses to 1110010001001111110 in binary \ which is 467582 in decimal \ which is the encoding of the string "Hel" s n \ finally, print n as a string  Note that I'm very doubtful this answer is optimal for Shtriped. Printing each character of Hello, World! or some combinations of its substrings could be much shorter, but doing that would require lots of trial and error and mathematical calisthenics (or at least a better golfer). For now, I like this elegant, if suboptimal solution. # Brain-Flak, 180, 176, 170 + 3 = 173 bytes ((()()())((((((((({})){}{}){}){}){})(((()()()){}()){}){}())([])[]{})))((((([][]()){}){})[[][]])<>)<>((((((({}))[]{}[][]())[][][])()()())[[]]()()()())[[]]()()())(<>{}()<>)  Try it online! This code is 170 bytes long, but adds three bytes for the -A flag, which is required to force brain-flak to input and output in ASCII. One little detail is that this also requires the -r flag, but it did not when I first wrote this answer, so I am not adding one byte for it. I'd post a detailed explanation, but this language hurts my brain... Thanks to @Wheatwizard for saving 4 10 bytes! Crossed out 4 is still regular 4... :( • You can save two bytes by moving the last 3 in the first push portion to the beginning and popping it for the first 3. (Since that is probably confusing here is a try it online) – Wheat Wizard Sep 6 '16 at 17:49 • You can also change ([]){} to [][]. (try it online) – Wheat Wizard Sep 6 '16 at 17:51 • @WheatWizard Good tips, thankyou! – James Sep 6 '16 at 17:53 • You can change (({})){}([])[](){} to (({}))[]{}[][](). (try it online) – Wheat Wizard Sep 6 '16 at 18:11 • Ok, two more: try it online – Wheat Wizard Sep 6 '16 at 18:19 # V, 14 bytes iHello, World!  Try it online! This enters insert mode, then inserts Hello, World! into the field. # Parenthetic, 766698 630 bytes ((()()())(()())((()())((()()())(()()()()))((()(())(())())((()(()))((()()(()))(()()())((())()()()()()()()()()()()()()))((()()(()))((())()()()()()())((())()()()()()))(()()()())))))((()(()))((()())((())()()())((())()()()))((()())((())()()()()())((())()()()()()()))((()())((())()()()()()())((())))((()())((())()()()()()())((())))((()())((())()()()()()())((())()()()))((()())((())())((())()))((()())((()))((())()()))((()())((())()()()())((())()()()()()))((()())((())()()()()()())((())()()()))((()())((())()()()()()())((())()()()()()()))((()())((())()()()()()())((())))((()())((())()()()()())((())()()()()()))((()())((()))((())()()())))  Try it online! Still got a lot to golf. This version uses a single definition (define f (lambda (a b) (char (+ (* a 13) 30 b))))  In other words, each char is encoded by two numbers a and b, for which 30 + 13*a + b is calculated (e.g. H = 73 = 30 + 3*13 + 3) . • nice work ... I thought it could be done better – MickyT Sep 4 '15 at 1:01 • 608 bytes using (define f (lambda (a b) (char (- (* 6 19) (* a 13) b)))) – Leaky Nun Aug 23 '17 at 11:00 • 604 bytes after golfing Leaky Nun's answer slightly – Sherlock9 Aug 23 '17 at 13:07 # Casio Basic, 15 Bytes "Hello, World!"  I think it explaines itself well enough... • Hello, and welcome to PPCG! This is a good answer; the downvote was an automatic Community downvote (AFAIK), and I cancelled it with an upvote. – NoOneIsHere May 30 '17 at 20:16 • Thanks and sorry that I messed up the formatting, I'm not really used to yet... – ADDB May 30 '17 at 20:17 • Perfectly OK! Just use four spaces before code, and a pound sign (#) or two before your header. – NoOneIsHere May 30 '17 at 20:18 # MY, 73 bytes Here's the hex: 07 24 21 21 28 26 0A 24 21 28 26 0B 24 20 20 28 26 0B 24 20 20 28 26 0B 24 21 28 26 04 24 21 21 21 21 28 26 02 25 28 26 09 24 20 20 20 28 26 0B 24 21 28 26 07 25 21 21 28 26 0B 24 20 20 28 26 0A 24 28 26 02 25 21 28 26  I didn't want to update my old answer, because this one isn't just a simple one-byte solution that uses a builtin. How it works: Outputs each character by using the few commands I have interpreted: • Number Literal: 0x00 - 0x0F • Minus 1: 0x20 • Add 1: 0x21 • Times 10: 0x24 • Times 16: 0x25 • Output: 0x26 • Character value: 0x28 # Pyramid Scheme, 857 bytes  ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ /out\ /out\ /out\ /out\ /out\ /out\ /out\ /out\ /out\ /out\ /out\ /out\ /out\ -----^ -----^ -----^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ /chr\ /chr\ /chr\ /chr\ /chr\ /chr\ /chr\ /chr\ /chr\ /chr\ /chr\ /chr\ ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ /72 \ /101\ /108\ /111\ /44 \ /32 \ /87 \ /111\ /114\ /108\ /100\ /33 \ ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----  Try it online! Wow. At least it's kinda clear how this works... # Sad-Flak, 199+3 bytes = 202 bytes 3 bytes for the -A arg. This lang uses a "codepage", where ≤≥ are one byte each (that is, I have a thing that replaces  and ~ with those chars and runs it) 32 ({}≤()≥) (≤()≥) 99 ({}≤()≥) ((<>[≤()≥])) 7 ({}≤()≥) ((<>))≤()≥ 5 ({}≤()≥) (≤()≥) 109 ({}≤()≥) (<>)(≤()≥) 85 ({}≤()≥) (≤()≥) 30 ({}≤()≥) (≤()≥) 42 ({}≤()≥) ({≤()≥})(({()}))({()})(()) 70 ({}≤()≥) ≤≥  Try it online! ## Explanation: The main idea behind this is that the way Sad-Flak works, you can easily get it to repeat a line a constant number of times. in Sad-Flak, there is a line pointer. The line pointer starts at the beginning -> 32 ({}≤()≥) (≤()≥) 99 ({}≤()≥) ((<>[≤()≥])) 7 ({}≤()≥) ((<>))≤()≥ 5 ({}≤()≥) (≤()≥) 109 ({}≤()≥) (<>)(≤()≥) 85 ({}≤()≥) (≤()≥) 30 ({}≤()≥) (≤()≥) 42 ({}≤()≥) ({≤()≥})(({()}))({()})(()) 70 ({}≤()≥) ≤≥  however, the 32 is not actually a command. it is a simple way to express 32 blank lines. I could expand them for the demonstration, but then it would be unreadable. anyway. So, the line pointer points at the first of 32 blank lines. When the line pointer points at a non-blank line, it will execute that line. when the line pointer points at a blank line, it will execute the first non-blank line after that line. that means we execute ({}≤()≥). What does this line do? This lang is a brainflak derivative, btw, so some of the brackets do the same thing, but not all ( push... {} pop off the main stack and evaluate to that value, plus ≤ jump by the amount inside, evaluate to that value for the purpose of other commands () 1 ≥ )  so, this pops off the stack, adds one to it while jumping one forward, then pushes back on the stack. What is jumping? why are we jumping in the middle of a line? Jumping in Sad-Flak is rather different to most other langs. Jumping does not take immediate effect, but rather moves the line pointer. when the line pointer is moved, nothing happens until the current line is finished executing. when it is finished, we see which line the line pointer points at, and execute that. If the line pointer didn't get moved, the same line gets executed again, and again, until it gets moved. however, all lines in this program either are blank, or they jump or halt. So, this line moves the line pointer one forward and increments top of stack. What is the line pointer pointing at now? it's still on a blank line, so it does the same thing again, and again, until it gets to the line that it keeps executing  32 -> ({}≤()≥) (≤()≥) 99 ({}≤()≥) ((<>[≤()≥])) 7 ({}≤()≥) ((<>))≤()≥ 5 ({}≤()≥) (≤()≥) 109 ({}≤()≥) (<>)(≤()≥) 85 ({}≤()≥) (≤()≥) 30 ({}≤()≥) (≤()≥) 42 ({}≤()≥) ({≤()≥})(({()}))({()})(()) 70 ({}≤()≥) ≤≥  Then, it executes it one last time, before moving to the next line. this end up with the charcode of ! on the stack (32 blanks + 1 actual line)  32 ({}≤()≥) -> (≤()≥) 99 ({}≤()≥) ((<>[≤()≥])) 7 ({}≤()≥) ((<>))≤()≥ 5 ({}≤()≥) (≤()≥) 109 ({}≤()≥) (<>)(≤()≥) 85 ({}≤()≥) (≤()≥) 30 ({}≤()≥) (≤()≥) 42 ({}≤()≥) ({≤()≥})(({()}))({()})(()) 70 ({}≤()≥) ≤≥  this line ((≤()≥)) pushes a new 1 to the stack, and moves the line pointer one forward, onto a new blank line, to do basically the same thing as it did before. however it puts charcode of e. and also the next line is this: ((<>[≤()≥])). What is this complex line? well: (( push twice... <> value popped from stack, and pushed onto the offstack for later retrieval [ minus ... ≤ (jump but eval to the argument still) () 1 ≥ ] ))  so, this pops the e off the stack, and replaces it with two ds, while leaving an e on the off stack for later retrieval, and also jumping the line pointer to the next line. we have two, because one will be changed into l, because it saves bytes from pushing a 1 and incrementing it up to the next letter. we don't do this for all of them because it also cost bytes popping and pushing back onto the stack, as well as fitting the jump in there. from now on, I'm skipping the blank lines and the increment top of stack lines, because this explanation is long enough already. after adding 8 to yield l (( push twice... <> a value popped from stack, also pushed to offstack )) ≤ jump ... () 1 ≥  add 6 to yield r: this one again: (≤()≥) new value at 111 (o): ( push... <> popped value, also pushed to offstack. ) ( push... ≤ (jump and eval to same as...) () 1 ≥ )  so this pushes to the off stack while keeping it on the stack, and pushing another 1 on the stack. new 87 (W): this again: (≤()≥) new 32 (space): same again: (≤()≥) new 44 (,): ({≤()≥})(({()}))({()})(()) woah, what is that? put simply, it is just pushing onto the main stack what we pushed on to the offstack, then a 1 to make into a H: ( push... { pop from the off stack, evaluate to that multiplied by... ≤ jump and eval to... () 1 ≥ } ) this pushes o (( push twice... { multiply an offstack popped value by... () 1 } )) this pushes l twice ( push... { offstack popped value times... () 1 } ) this pushes e ( push... () 1 )  new 72 (H): ≤≥: this is the halt command and it stops the program That pushed !dlroW ,olleH char codes, which then gets printed, but backwards because it is a stack. "Hello, World!" # Cubically, 12412311199 78 bytes -11 bytes thanks to TehPers, -12 thanks to language updates, -21 thanks to user202729 RU+432@6+50-4@6+3-4@6@6+1-00@6-331@6-00@6+4110@6+0000@6+1-00@6-0@6-2+4@6-331@6  Generated via this amazing algorithm. There is a good explanation of Cubically in this question. Cubically, the Rubik's Cube Programming Language, is the most complex language I have ever written, or dealt with, for that matter. It entirely comprises of operations on a single 3x3 Rubik's Cube in its memory, and one extra value, the "notepad". The only way to perform mathematical operations is to take values from a certain cube face and add/subtract/multiply/divide it with the scratch pad value, replacing said value. For example, performing /0 divides the notepad value by the sum of all integers on the 0-indexed face, or the first face. The cube starts out initialized like this:  000 000 000 111222333444 111222333444 111222333444 555 555 555  Performing a 90-degree clockwise turn on the right face will make the cube look like this:  002 002 002 111225333044 111225333044 111225333044 554 554 554  Version from TehPers: Here's a run-down of how the program works: (Note that I have replaced @6 with @ in the code, but changing each instance in the rest of this answer would be too tedious and I need to get back to real life.) • +53 adds the DOWN face and RIGHT faces into the notepad, in this case, 45 and then 27. This results in 72, the ASCII code for H. • @6 prints the notepad value as ASCII. • :2 sets the notepad to the value of the FRONT face (18). • /1 divides the notepad by the LEFT face (9), resulting in 2. • +551 Adds the DOWN face (45) twice, then the LEFT face (9). As you can see, without rotating the cube, the faces will contain a total value equal to 9 times the index. For example, face index 5 has a value of 45, face index 1 has a value of 9, and so forth. After rotating the cube, this no longer applies. • @6 again prints the notepad value, or e. • :5 sets the notepad to the value of the DOWN face (45). • +52 adds the DOWN face (45) and the FRONT face (18) to the notepad. • @66 prints the current notepad value as a character twice. At this point Hell has been printed, which should be good enough for this language. :P • :3/1 sets the notepad to the value of the RIGHT face (27), then divides the notepad by the value of the LEFT face (9), resulting in 3. Do you see the pattern yet? • +552 adds 108 to the notepad, or 9*(5+5+2). Remember, if you rotate the cube, then the faces will not necessarily be multiples of 9! • @6 prints the notepad value as a character, finishing the word "Hello". • From this point there is nothing interesting. The program follows the pattern of setting the notepad value to whatever c % 9 is (where c is the target character), then adding multiples of 9 to the notepad get to the target character. The faces are not rotated, so this isn't exactly the best showcase program for Cubically, but it's certainly simpler than what could be accomplished with rotating the faces. There may be a shorter way to write this program using rotations, though. Original (written by hand >.<) +53@6+1F2L2+0@6L2F2U3R3F1L1+2@66L3F3R1U1B3+0@6:4U1R1+00@6-000@6+50000@6+000000@6+2-000000@6-5+4000@6-00@6/0+00@6:0+0/0+00@6  The above Hello World program uses arbitrary turns that I fiddled with until they got some desired values. Eventually, I got the top face to add up to 4 and made do with that. Here's a run-down of how the program works: • +5+3 adds the DOWN face and RIGHT faces into the notepad, in this case, 45 and then 27. This results in 72, the ASCII code for H. • @6 prints the notepad value as ASCII. • +1 adds the LEFT face to the notepad value, resulting in 81. • F2 turns the FRONT face to look like this. • L2 turns the LEFT face to look like this. • +0 adds the UP face to the notepad, resulting in 101. • @6 prints memory as ASCII e. • L2F2U3R3F1L1 turns the cube to look like this. • +2 adds the FRONT face to the notepad, resulting in 108. @66 prints as ASCII twice ll. At this point Hell has been printed, which should be good enough for this language. :P • L3F3R1U1B3 turns the cube to look like this. • +0 adds the UP face to the notepad (resulting in 111), @6 prints it as ASCII o. • :4 sets the notepad to the BACK face 36. • U1R1 turns the cube to look like this. The cube is not turned again 'cause this was about as good of a setup I could get. • +0+0 adds the UP face to the notepad twice, resulting in 44. • @6 prints as ASCII ,. • -000 subtracts 12 from the notepad (32). @6 prints as ASCII . • From this point there is nothing interesting except messing with the existing faces, particularly the top face (which has a convenient value 4), to print the remaining characters. • It's not complex, just insanely difficult :o – hyper-neutrino Jun 15 '17 at 0:45 • @HyperNeutrino It's rather complex. Wait for the explanation :P – MD XF Jun 15 '17 at 0:46 • you should change the title on this – Destructible Lemon Jun 15 '17 at 1:32 • Also that is not postfix – Destructible Lemon Jun 15 '17 at 1:32 • @DestructibleLemon oh duh – MD XF Jun 15 '17 at 1:38 # Pepe, 122 120 bytes Pepe is my brand new programming language, which is horrible. reeEeeEeeereeEEeeEeErEeEEeEEeereeereeeREeEEeEEEEReeereeeEeEEeereeeEeeeeereeEeEeEEEReeereeEEEeeEereeereeEEeeEeereeeEeeeeE  Try it online! There might be shorter solutions, but that's not task for my brain .-. That's why I'd offer a 50 100 bounty to anyone who can make it shorter, if it's possible. I don't really believe it is, but maybe you can change my mind? This solution is quite simple, but better to explain it ungolfed and commented: reeEeeEeee # H > print H reeEEeeEeE # e > print e rEeEEeEEee # l > push l to r reee reee # print it twice REeEEeEEEE # o > push o to R Reee # print it reeeEeEEee # , > print , reeeEeeeee # > print a space reeEeEeEEE # W > print W Reee # o > print active value in R (o) reeEEEeeEe # r > print r reee # l > print active value in r (l) reeEEeeEee # d > print d reeeEeeeeE # ! > print !  The first line prints Hello, and a space, the second prints World!. Most of this program are character functions, ex. reeEeeEeee which prints H. By letter: • r - Stack r • e - Print • eEeeEeee - 01001000 (72), the ASCII character for H As said, most of the program consists of similar commands, but, to golf it a bit, in first occurrence of l, I replaced the first e with E, so instead of printing, it pushed the charcode to the stack. Thanks to this, we can later print l using reee, the command for printing. Edit: Now, I've done the same with o, thanks to the existence of the second stack (notice the R letter). # Symbolic Python, 175 157 147 136 bytes _=-~(_==_) _*=_-~_ __=_*_+~-~-_ _=('%'+' '[~_/_])*-~-~_%(~-_*~-~-_,_*_+_/_,__,__,_*_-~_,',',' ',__-_+~_,_*_-~_,_==_[_/_],__,_*_)+'!'  Try it online! I'm not sure this is optimal, but it sure was fun. ### Explanation: _=-~(_==_) # Set _ to 2 _*=_-~_ # Set _ to 2*(2+2+1) = 10 __=_*_+~-~-_ # Set __ to 10*10+(10-1-1) = 108 _= # Set _ to ('%'+''[~_/_]) # %c, where c is coming from the character \x0c *-~-~_ # Repeated 12 times %(... # Then format into that format string ~-_*~-~-_, # (10-1)*(10-1-1) = 72 = 'H' _*_+_/_, # 10*10+1 = 101 = 'e' __, # 108 = 'l' __, # 108 = 'l' _*_-~_, # 10*10+10+1 = 111 = 'o' ',', # ',' ' ', # ' ' __-_+~_, # 108-10-(10+1) = 87 = 'W' _*_-~_, # 10*10+10+1 = 111 = 'o' _==_[_/_], # second letter of True = 'r' __, # 108 = 'l' _*_ # 10*10 = 100 = 'd' )+'!' # Then add the last char '!' # And implicitly print _  # AArch64 machine language Linux, 48 45 bytes  0: d2800020 mov x0, #0x1 ; stdout is fd=1 4: d28001a2 mov x2, #0xd ; length of string 8: 94000001 bl c ; put addr of pc to x30 c: 910053c1 add x1, x30, #0x14 ; put addr of string to x1 10: d2800808 mov x8, #0x40 ; select write() syscall 14: d4000001 svc #0x0 ; syscall 18: d2800bc8 mov x8, #0x5e ; select exit() syscall 1c: d4000001 svc #0x0 ; syscall 20: 6c6c6548 "Hello, World!" 77202c6f 646c726f 21  To try it out on an AArch64 Linux machine or Android device with Termux, compile and run the following C program. You may need to pass the -zexecstack argument to the compiler. const char main[]=" \0\x80\xd2\xa2\1\x80\xd2\1\0\0\x94\xc1\x53\0\x91\b\b\x80\xd2\1\0\0\xd4\xc8\v\x80\xd2\1\0\0\xd4Hello, World!"  # 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 # Cubically, 48 46 bytes The previous best answer seems to have been 78 bytes long. I consider this a victory. +35@⊕5@⊕1L@@|4U@-53@-0@R+43@+4@B'⊕3@-0@F-0@:5@  Found via computer search within a restricted subset of Cubically. Corresponding Most efficient cubifier answer by me. Try it online! # PowerShell, 15 Bytes Likely in Foo (among others) as well, but I'll let someone with more knowledge of those languages post. "Hello, World!"  or, alternatively, 'Hello, World!'  In PowerShell, both ' and " denote string literals. The difference is the double-quotes will expand variables (e.g., $myString) and escape characters (e.g.,  n), while the single-quote will treat everything literally.

PowerShell does an implicit Write of anything that's on a line by itself in a program (the relative merits of Write-Host vs Write-Output are left as an exercise to the reader) -- variable, literal string (as this is), result of a one-line command, etc. This stems from the fact that every line gets executed, and the way to execute a string is to print it. For other data types, if they have a way to convert to a string, the execution silently does the conversion in the background and then prints the resultant string. If there's no way to get a string, you'll wind up printing a description of the datatype. This is one of the ways that PowerShell, as ... verbose clear ... as it is, can wind up somewhat competing with other languages.

A short article on the topic, not written by me, though the author and I have a similar name.

# vJASS (Warcraft 3), 78 58 bytes

Using //! import zinc "<code_path>" command to exclude //! zinc and //! endzinc.

library a{function onInit(){BJDebugMsg("Hello, World!");}}


Explanation:

• BJDebugMsg() prints the text on your in-game screen.

# Forth, 17 bytes

.( Hello, World!)

• ." Hello World! is one byte shorter. – Lynn Aug 28 '15 at 20:27
• ." may only be used within a function declaration. ." : error(-14): use only during compilation – mbomb007 Aug 28 '15 at 20:47
• Why the space in .( Hello,? – Erik the Outgolfer Jun 16 '16 at 14:56
• @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Forth requires spaces between tokens. The ending ) is the exception to the rule. – mbomb007 Jun 16 '16 at 14:56
• @mbomb007 It's unfair that ." is only in functions. – Erik the Outgolfer Jun 16 '16 at 15:03

# Batch File, 19 Bytes

@echo Hello, World!


Short and to the point. You'd think you could golf off the @ at the beginning, but if you do you get the literal program echo'd out before the string is printed. This is why you'll see @echo off at the beginning of near every .bat file around.

Example without the @

C:\Tools\Scripts>.\hello-world.bat

C:\Tools\Scripts>echo Hello, World!
Hello, World!

• Isn't the language itself just called "Batch"? – mbomb007 Aug 28 '15 at 13:54
• @mbomb007 Kinda, sorta, maybe, not really. Batch files are just collections of lines that are executed by the associated command-line interpreter (usually COMMAND.COM but not necessarily, especially in newer Windows releases). It technically has some additional commands, like the infamous GOTO, but it's not in and of itself a language. – AdmBorkBork Aug 28 '15 at 14:11
• If you leave off the the echo you get an infinite amount of hello world!'s – User112638726 Aug 28 '15 at 14:21
• @User112638726 No, you should get something like 'Hello' is not recognized as an internal or external command, operable program or batch file. If you get something else, you must be using a different version of the interpreter than I am. – AdmBorkBork Aug 28 '15 at 14:28
• @MrPaulch if the filename is significant it has to be added to the byte coutn – undergroundmonorail Aug 30 '15 at 23:01

# J, 15 bytes

'Hello, World!'


No call to any write function needed.

# 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!")}


# Bash, 18 bytes

echo Hello, World!


This works when invoked as a full program or with history expansion disabled (default for scripts).

# Applescript, 15 bytes

"Hello, World!"


Normally a fairly verbose language, for this one this is all that is required.

• It's nice to see these verbose languages -- Applescript, PHP, PowerShell, etc. -- getting the better of lots of other languages for once. :) – AdmBorkBork Aug 28 '15 at 15:53
• @TimmyD That doesn't mean that they are good languages. It's just that they are better at some things. – galexite Aug 28 '15 at 16:53
• @georgeunix Oh, without a doubt. Every language has its pluses and minuses. There are plenty of things I'd change about PowerShell, but there's nothing else I'd rather use to script and config Exchange. Even if it had commands and functionality to do so, I don't think I could use Pyth or CJam or whatnot on a day-to-day basis instead. I was just meaning "It's nice to see non-golfing languages toward the top of the lowest-byte-count list for a change." – AdmBorkBork Aug 28 '15 at 17:06
• I understand @TimmyD – galexite Aug 28 '15 at 17:07

# Julia, 22 bytes

print("Hello, World!")


Short and sweet.

# D, 51 bytes

import std.stdio;void main(){puts="Hello, World!";}


In D, a=b is sometimes equivalent to a(b), allowing us to shave off one more byte than you might expect.