# "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. Aug 28, 2015 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? Aug 28, 2015 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. Aug 28, 2015 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. Aug 29, 2015 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. May 20, 2018 at 10:20

# 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 Jun 15, 2017 at 0:45
• @HyperNeutrino It's rather complex. Wait for the explanation :P Jun 15, 2017 at 0:46
• you should change the title on this Jun 15, 2017 at 1:32
• Also that is not postfix Jun 15, 2017 at 1:32
• @DestructibleLemon oh duh Jun 15, 2017 at 1:38

## Folders (pure), 195 folders

Some languages, like Folders, are a bit tricky to score

I'm not sure how it translates to bytes, but we can just count the number of folders: (src)

$ls -l -R . | grep -c ^d 195  $ ls -l -R . | grep :$./New folder: ./New folder/New folder: ./New folder/New folder/New folder: ./New folder/New folder/New folder (2): ./New folder/New folder/New folder (3): ./New folder/New folder/New folder (4): ./New folder/New folder (2): ./New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder/New folder: ./New folder/New folder (2)/New folder/New folder (2): ./New folder/New folder (2)/New folder/New folder (3): ./New folder/New folder (2)/New folder/New folder (4): ./New folder/New folder (2)/New folder/New folder (5): ./New folder/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy: ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (4)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (10): ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (11): ./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (12): ./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder (2)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (4)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (5): ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (6): ./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (7): ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (4)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (4)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (8): ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (4)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (9): ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (3): ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (3)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (4): ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (4)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2): ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2)/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2)/New folder/New folder: ./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2)/New folder (2):  ## Folders (concise), 2 folders + (5 + 13) bytes ./Setup ./Setup/Hello, World!  • Welcome to PPCG! / Using inline code formatting can be quite hard to read, I edited the answer. Feb 2, 2018 at 10:29 • Does this include the comma? I don't see one in your concise version but I don't have a folders installation to check. Feb 6, 2018 at 22:21 • According to the original site, (and by the number of folders) it is with the comma. I fixed my concise example. Feb 7, 2018 at 0:44 • Easier way to count: find * -type f | wc -l (counts lines of output) Apr 13, 2018 at 2:57 • Right, It is shorter by one character... But I could use -lR Apr 14, 2018 at 8:21 # 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). # 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 Aug 27, 2019 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! # Integral, 13 bytes ÷Hello, W╗ld!  Try it! Sadly, Integral cannot yet compress capital letters, so it could not do much compression. ÷ means start compressed string. Ignoring punctuation and capitalization yields # Integral, 9 bytes ÷▓llo═╗ld  Try it! See also: Showcase • Can you put Integral on GitHub? – user96495 Aug 3, 2020 at 0:38 • Also, how do loops work? I tried using e but it froze the interpreter. Aug 3, 2020 at 0:38 • @Lyxal You would push the string to eval, then push the number of times to loop. Example: ⌡[Code to eval]⌡;[Encoded number of times];e – nph Aug 3, 2020 at 12:59 • @petStorm GitHub repository. For some reason the code is not working. For now keep using the old interpreter. – nph Aug 3, 2020 at 13:19 • Anyway, I created a GitHub pages online interpreter. – user96495 Aug 3, 2020 at 13:53 # 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. # Windows Portable Executable 32 bit, 268 bytes xxd: 00000000: 4d5a 0000 5045 0000 4c01 0100 0000 0000 MZ..PE..L....... 00000010: 0000 0000 0000 0000 7000 0301 0b01 0000 ........p....... 00000020: 0000 0000 0000 0000 0000 0000 b400 0000 ................ 00000030: 0000 0000 0000 0000 0000 4000 0400 0000 ..........@..... 00000040: 0400 0000 0000 0000 0000 0000 0400 0000 ................ 00000050: 0000 0000 0004 0000 0100 0000 0000 0000 ................ 00000060: 0300 0000 0000 0000 0000 0000 0000 0000 ................ 00000070: 0000 0000 0000 0000 0200 0000 0000 0000 ................ 00000080: 0000 0000 e600 0000 0000 0000 2e74 6578 .............tex 00000090: 7400 0000 4600 0000 b400 0000 4600 0000 t...F.......F... 000000a0: b400 0000 0000 0000 0000 0000 0000 0000 ................ 000000b0: 0000 0000 68c5 0040 00ff 15da 0040 00ff ....h..@.....@.. 000000c0: 15de 0040 0048 656c 6c6f 2c20 576f 726c ...@.Hello, Worl 000000d0: 6421 0063 7274 646c 6c00 bb01 0080 6701 d!.crtdll.....g. 000000e0: 0080 0000 0000 0000 0000 0000 0000 0000 ................ 000000f0: 0000 d300 0000 da00 0000 0000 0000 0000 ................ 00000100: 0000 0000 0000 0000 0000 0000 ............  source: ; nasm BITS 32 base equ 0x400000 ; ; DOS header ; ; The only two fields that matter are e_magic and e_lfanew mzhdr: dw "MZ" ; DOS e_magic dw 0 ; ; NT headers ; dd "PE" ; PE signature ; ; NT file header ; filehdr: dw 0x014C ; Machine (Intel 386) dw 1 ; NumberOfSections dd 0 ; TimeDateStamp UNUSED dd 0 ; PointerToSymbolTable UNUSED dd 0 ; NumberOfSymbols UNUSED dw opthdrsize ; SizeOfOptionalHeader dw 0x103 ; Characteristics ; ; NT optional header ; opthdr: dw 0x10B ; Magic (PE32) db 0 ; MajorLinkerVersion UNUSED db 0 ; MinorLinkerVersion UNUSED dd 0 ; SizeOfCode UNUSED dd 0 ; SizeOfInitializedData UNUSED dd 0 ; SizeOfUninitializedData UNUSED dd start ; AddressOfEntryPoint dd 0 ; BaseOfCode UNUSED dd 0 ; BaseOfData UNUSED dd base ; ImageBase dd 4 ; DOS e_lfanew ; SectionAlignment dd 4 ; FileAlignment dw 0 ; MajorOperatingSystemVersion UNUSED dw 0 ; MinorOperatingSystemVersion UNUSED dw 0 ; MajorImageVersion UNUSED dw 0 ; MinorImageVersion UNUSED dw 4 ; MajorSubsystemVersion dw 0 ; MinorSubsystemVersion UNUSED dd 0 ; Win32VersionValue UNUSED dd 1024 ; SizeOfImage dd 1 ; SizeOfHeaders nonzero for Windows XP dd 0 ; CheckSum UNUSED dw 3 ; Subsystem (Console) dw 0 ; DllCharacteristics UNUSED dd 0 ; SizeOfStackReserve dd 0 ; SizeOfStackCommit dd 0 ; SizeOfHeapReserve dd 0 ; SizeOfHeapCommit UNUSED dd 0 ; LoaderFlags UNUSED dd 2 ; NumberOfRvaAndSizes for Windows 10; UNUSED in Windows XP ; ; Data directories (part of optional header) ; dd 0, 0 ; Export Table UNUSED dd idata, 0 ; Import Table opthdrsize equ$ - opthdr

;
;

db ".text", 0, 0, 0         ; Name
dd codesize                 ; VirtualSize
dd codesize                 ; SizeOfRawData
dd code                     ; PointerToRawData
dd 0                        ; PointerToRelocations UNUSED
dd 0                        ; PointerToLinenumbers UNUSED
dw 0                        ; NumberOfRelocations UNUSED
dw 0                        ; NumberOfLinenumbers UNUSED
dd 0                        ; Characteristics UNUSED

;
; Code section data
;

align 4, db 0

code:

;
; Entry point
;

start:
push base + msg
call [base + puts]
call [base + exit]

msg:
db "Hello, World!",0

crt:
db "crtdll",0

;
; Import address table (array of IMAGE_THUNK_DATA structures)
;

iat:
puts:   dd 0x800001BB           ; Import puts by ordinal
exit:   dd 0x80000167           ; Import exit by ordinal
dd 0                    ; terminator

;
; Import table (array of IMAGE_IMPORT_DESCRIPTOR structures)
;

idata:
dd 0                        ; OriginalFirstThunk UNUSED
dd 0                        ; TimeDateStamp UNUSED
dd 0                        ; ForwarderChain UNUSED
dd crt                      ; Name
dd iat                      ; FirstThunk

; terminator
;    times 5 dd 0 ; too big, padding serves as terminator

codesize equ $- code ; ; Padding for Windows 10 ; times 268 - ($-) db 0


This program was tested on Windows 10 2004 64-bit and Windows XP SP3.

The answer is based on this article, which creates the smallest PE file on Windows XP. I took the smallest file that works on Windows 10 from tinype.zip, which is tiny.296, and added imports using tiny.import.209. Other useful articles: one two.

Quirks:

Windows 10:

• 268 byte size limit (link)
• imports must be in a section (link), that's why codesize includes imports

Windows XP:

• ignores NumberOfRvaAndSizes, it's not a problem because Debug Directory size happens to be 0 (Characteristics field of .text section header) (link)
• SizeOfHeaders must be nonzero

I think 268 = 4 + 264, where 4 is the minimal offset of NT headers from the start of the file and 264 is the minimal distance between the start of NT headers and end of file. 264 is probably sizeof(IMAGE_NT_HEADERS32)+16 or sizeof(IMAGE_NT_HEADERS64). Because Windows 10 imposes hard limit on minimal PE size, there is no need to cram section header, code and imports into NT headers.

Of the four CRT libraries that are available on both XP and 10 (crtdll.dll, msvcrt.dll, msvcrt20.dll, msvcrt40.dll), I use crtdll.dll because it has a shorter name and has not been updated since 1995, so (it feels like) it's safe to import by ordinals from it. There is no big problem to import by names, but then those names must be inside headers, which is a bit messier.

The program sometimes hangs if puts is imported and ret is used to exit the program (this is true for both crtdll and msvcrt), so I use exit.

# Haifuckqueue, 59 39 bytes

good job to @emanresu A for being epic gamer (shaved off a stanza)

you can only make improvements of 20 bytes at a time because of the haiku 5 7 5 rules lol

{H}$1 {lo, W} p{l}p {e}$7
{orld!}
$5ooo  ### Explanation: {H}$1    -- overwrite top item on stack with "H" and pop that one item and print it
{lo, W}  -- overwrite top 5 with "lo, W"
p{l}p    -- push 0 to the top of the stack and overwrite it with "l" and push another 0
{e}$7 -- Overwrite the pushed zero with an "e" and print top 7 ("ello, W") {orld!} -- Push "orld!"$5ooo    -- pop and print top 5 and pad with o command (xor top 2 items and put result in 3) for haiku 5 7 5 rules


Try it online!

• You probably want to add a timeout on the server - It's currently printing millions upon millions of A to STDOUT with no sign of stopping anytime soon. Nov 23, 2021 at 9:41
• Golfed off a stanza! Nov 24, 2021 at 18:59
• i can't seem to reproduce the million print thing but i think i added a working timeout now of 5 seconds Nov 25, 2021 at 22:46
• bruh hacks @emanresu Nov 25, 2021 at 22:47
• i guess you mean if you try to use the goto line number thing it will go forever Nov 25, 2021 at 22:59

# 10IPL, 67 bytes

00010000 00100000 00100000 00100000 00010000 00100000 00100000 00100000 00110000 00010010 00100010 00100010 00010010 00100010 00010010 00100010 00100010 01000001 00010000 00110000 00010100 00100100 00100100 00100100 00010100 01000010 00110000 00110000 00010000 00010000 00010000 00110000 00110010 00010110 00100110 00100110 00100110 00100110 01100011 00100110 00110110 00010100 00010100 00010100 00100100 01010000 00110100 00110000 00010000 00010000 00010000 00110000 00010100 00010100 00010100 00010100 00010100 01010100 00110100 00011010 00101010 00101010 00101010 01010101 00110100 00010110 00110110


Try it online!

Program:

inr r0
rtr r0
rtr r0
rtr r0
inr r0
rtr r0
rtr r0
rtr r0

prt r0

inr r1
rtr r1
rtr r1
inr r1
rtr r1
inr r1
rtr r1
rtr r1
xor r0, r1
inr r0

prt r0

inr r2
rtr r2
rtr r2
rtr r2
inr r2
xor r0, r2

prt r0
prt r0

inr r0
inr r0
inr r0

prt r0

prt r1

inr r3
rtr r3
rtr r3
rtr r3
rtr r3
xor r4, r3
rtr r3

prt r3

inr r2
inr r2
inr r2
rtr r2
xor r2, r0

prt r2

prt r0

inr r0
inr r0
inr r0

prt r0

inr r2
inr r2
inr r2
inr r2
inr r2
xor r2, r4

prt r2

inr r5
rtr r5
rtr r5
rtr r5
xor r2, r5

prt r2

inr r3
prt r3


What is 10IPL?

10IPL, short for 10 Instruction Programming Language, is a simple compiled language I made for use in a computer I'm building in Minecraft. I made an online interpreter for it (with a few extra features), since I think it's a neat language.

How does this work?

This program doesn't have anything fancy, it just uses three of 10IPL's instructions (Increment, Rotate, and XOR) to put numbers in registers, then prints them.

10IPL has four general purpose registers, r0 to r3. It also has r4 (or rp0) and r5 (or rp1), which are intended to hold pointers. I use these as normal registers to save having to waste bytes clearing the ones I've already used, since this program never needs to access memory.

# Halfwit-A, 15 bytes

>JM?M;J*?f?*M[?JN;k+Jkk;$<5b  Try It Online! Halfwit is an experimental golfing language that fits most commands in half a byte. It only uses lists and integers, so the -A flag allows it to output characters. This approach is pretty simple. The bit between > and < is the compressed integer 1408073740711211456312062497. 5 is the constant 128, which actually takes up 1.5 bytes because reasons, then b decompresses the integer into base 128. The naïve approach of using a character list comes out at 19.5 bytes: >*{>N;>N:>N:>Nk>;{>{+>J;>Nk>f{>N:>N{>{*  Try It Online! Each segment between > is a base-14 compressed integer. # TI-BASIC, 22 bytes "Hello, World!  Note that the lowercase letters are 2 bytes each. • I don't think the initial : is really part of the program, so I think this has a score of 22. Aug 28, 2015 at 16:06 • @Ypnypn I'll take your word on it :) Aug 28, 2015 at 18:45 • The colon definitely counts! It's like the C/C++ semicolon, except prefix instead of postfix. If you didn't know, you can enter multiple expressions on a single line by seperating them with a colon. Even if not that, the post asked for a full program, so it has to be there anyways. Mar 14 at 14:51 • The lowercase letters can be entered on a TI-84. Mar 14 at 15:45 • @Itay123 I rolled back your changes because they were mostly incorrect. If you look at the edit history of this question, you will see that the original included a colon. However, most of the readers from 6 years ago preferred it to not be counted. Because of that and the question's age, I would prefer to not re-introduce the colon into the answer. Mar 15 at 16:28 # Forth, 17 bytes .( Hello, World!)  • ." Hello World! is one byte shorter. – Lynn Aug 28, 2015 at 20:27 • ." may only be used within a function declaration. ." : error(-14): use only during compilation Aug 28, 2015 at 20:47 • Why the space in .( Hello,? Jun 16, 2016 at 14:56 • @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Forth requires spaces between tokens. The ending ) is the exception to the rule. Jun 16, 2016 at 14:56 • @mbomb007 It's unfair that ." is only in functions. Jun 16, 2016 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"? Aug 28, 2015 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. Aug 28, 2015 at 14:11 • If you leave off the the echo you get an infinite amount of hello world!'s Aug 28, 2015 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. Aug 28, 2015 at 14:28 • @MrPaulch if the filename is significant it has to be added to the byte coutn Aug 30, 2015 at 23: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!")}  # 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. :) Aug 28, 2015 at 15:53 • @TimmyD That doesn't mean that they are good languages. It's just that they are better at some things. Aug 28, 2015 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." Aug 28, 2015 at 17:06 • I understand @TimmyD Aug 28, 2015 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. # Unlambda, 36 bytes .!.d.l.r.W. .,.lc.H.e.oi  Unlambda is a minimal functional programming language based on combinatory logic. It uses prefix notation; fx is an application of f to x. Specifically, .c is a primitive that takes some v, prints the character c as a side-effect, and returns v. Thus, the usual program would be to take i, apply .H to it, apply .e to it, etc., giving you .!.d.l... This 36-byte solution is due to irori on anarchy golf. It uses the primitive c, which I think is kind of like call/cc, to avoid having to write .o and .l twice. I have no idea how it precisely works. The sort-of equivalent Lisp syntax would be: (print-! (print-d (print-l (print-r ((print-W (print-space (print-comma ((print-l (call-cc (print-h print-e))) print-o)))) id)))))  # 4, 117 bytes 3.6000160103602136033260433605446067260787008070200908000120902111120111011015065095105105115055035075115125105085044  ### How it works Generating characters with a code point below 100 is straightforward. I've managed to create the others (derol) with three assignments and five additions/subtractions, which I believe is optimal. 3. Begin the program. 6 00 01 Set cell[ 0] to 1. 6 01 03 Set cell[ 1] to 3. 6 02 13 Set cell[ 2] to 13. 6 03 32 Set cell[ 3] to 32 = ' '. 6 04 33 Set cell[ 4] to 33 = '!'. 6 05 44 Set cell[ 5] to 44 = ','. 6 06 72 Set cell[ 6] to 72 = 'H'. 6 07 87 Set cell[ 7] to 87 = 'W'. 0 08 07 02 Set cell[ 8] to cell[ 7] + cell[2] = 87 + 13 = 100 = 'd'. 0 09 08 00 Set cell[ 9] to cell[ 8] + cell[0] = 100 + 1 = 101 = 'e'. 0 12 09 02 Set cell[12] to cell[ 9] + cell[2] = 101 + 13 = 114 = 'r'. 1 11 12 01 Set cell[11] to cell[12] - cell[1] = 114 - 3 = 111 = 'o'. 1 10 11 01 Set cell[10] to cell[11] + cell[1] = 111 - 3 = 108 = 'l'. 5 06 Print cell[ 6] = 'H'. 5 09 Print cell[ 9] = 'e'. 5 10 Print cell[10] = 'l'. 5 10 Print cell[10] = 'l'. 5 11 Print cell[11] = 'o'. 5 05 Print cell[ 5] = ','. 5 03 Print cell[ 3] = ' '. 5 07 Print cell[ 7] = 'W'. 5 11 Print cell[11] = 'o'. 5 12 Print cell[12] = 'r'. 5 10 Print cell[10] = 'l'. 5 08 Print cell[ 8] = 'd'. 5 04 Print cell[ 4] = '!'. 4 End the program.  # Var'aQ, 20 bytes "Hello, World!" cha'  Var'aQ nIv rur Hol. 'oH rut lo' jIH ngaj-ghItlh. Note: ghu'vam laH mugh jIH vaj DaneH'a'. • mughwI' vItu' 'oHbe' majQa'. Sep 1, 2015 at 14:48 • @mbomb007 Qo', jIHvaD pIch, bing pIch Sep 1, 2015 at 14:51 • What language is this? Sep 28, 2015 at 1:00 • @LegionMammal978 Klingon :) Sep 28, 2015 at 5:52 # 123, 282 267 bytes 22221121121112112222222211211112111211211222222221121121133121121312121122222222111211213 31211213122222222111211332113312112222221112112331123322222221111211111211222221111211211 22222222112111112112112112222222111112112112112222213312112131222222221121113321133121121  The newlines are only for cosmetic purposes. I'm fairly sure that this is not optimal. Here is a slightly more readable (and also runnable) version: H 22221121121112112 e 2222222112111121112112112 l 22222221121121133121121312 l 12112 o 22222221112112133121121312 , 2222222111211332113312112 2222211121123311233 W 222222211112111112112 o 222211112112112 r 2222222112111112112112112 l 222222111112112112112 d 2222133121121312 ! 2222222112111332113312112 1  I started out by constructing an optimal linear code (i.e. one which doesn't use 3s which allow for loop). That is quite simple: for each character, determine which bytes to flip from the last one. Move to the right-most character that has to be flipped (with a series of 2s), then move back to the left with 1 for each byte that has to be flipped and 121 for each byte that shouldn't be flipped. Finally move to the writing index -2 and print the character with 21. Repeat. At the very end, move to index -1 with a trailing 1 in order for the program to terminate. This jumble of 1s and 2s was generated with this CJam script, which you can run online here: 0c"Hello, World!"+2ew::^{ _{2b8Ue[1a/W<1a*_,'2*'1@W%{'1"121"?}/"12"}{;"12112"}? }/ '1  Then I removed some repetition of ones and twos by inserting loops by hand. 3 works as follows: if the instruction pointer is to the left of index 0, skip the 3. Otherwise, jump to the previous 3 if the current bit is 1 or jump ahead to the next 3 if the bit is 0. So simple loops, repeating a code segment x can be constructed as 33x33 or 33x3 (depending on whether the termination condition is "current bit is zero" or "moved to a negative index"). Then I started enumerating some relevant simple loops and when they are applicable. I've been using these loops only when moving back through the bits to change one character code to the next. If we can use a loop here depends both on the current state of a bit a and the target state b. I'll be denoting this combined state of each position as [a b]. Now here are the relevant loops and the required position patterns in a regex-like syntax: 121: (^|[0 0]|[0 1]) ([1 1])+ [0 0] 112: (^|[1 1]) ([0 0])+ ([0 1]|[1 1]) 211: ([0 0]|[0 1]) ([1 1])+ [0 0] ([0 0]|[1 1]) 121121: ([0 0]|[0 1]) ([1 1] ([1 1]|[0 0]))+ [0 0]  Listing out the combined states for each character, we can annotate the potential loops and how many bytes they'll save (each ___ annotates the character above; sometimes multiple loops are possible): H [[0 0] [0 1] [0 0] [0 0] [0 1] [0 0] [0 0] [0 0]] e [[0 0] [1 1] [0 1] [0 0] [1 0] [0 1] [0 0] [0 1]] l [[0 0] [1 1] [1 1] [0 0] [0 1] [1 1] [0 0] [1 0]] __________________121 -2 ________________________121121 -3 l [[0 0] [1 1] [1 1] [0 0] [1 1] [1 1] [0 0] [0 0]] o [[0 0] [1 1] [1 1] [0 0] [1 1] [1 1] [0 1] [0 1]] __________________121 -2 __________________211 -2 ________________________121121 -3 , [[0 0] [1 0] [1 1] [0 0] [1 1] [1 1] [1 0] [1 0]] ________________________211 -2 [[0 0] [0 0] [1 1] [0 0] [1 0] [1 0] [0 0] [0 0]] ____________112 -2 W [[0 0] [0 1] [1 0] [0 1] [0 0] [0 1] [0 1] [0 1]] o [[0 0] [1 1] [0 1] [1 0] [0 1] [1 1] [1 1] [1 1]] r [[0 0] [1 1] [1 1] [0 1] [1 0] [1 0] [1 1] [1 0]] l [[0 0] [1 1] [1 1] [1 0] [0 1] [0 1] [1 0] [0 0]] d [[0 0] [1 1] [1 1] [0 0] [1 0] [1 1] [0 0] [0 0]] __________________121 -2 ________________________121121 -3 ! [[0 0] [1 0] [1 1] [0 0] [0 0] [1 0] [0 0] [0 1]] ________________________211 -2  Now I just picked the most profitable loop in each case and inserted it into the code. I'm fairly certain that one could find a couple more loops that I've overlooked. But I also think that it's possible to find a significantly shorter solution that isn't based on anything a human would come up with. So far I have no idea how to efficiently search for such a solution automatically though, so I'll leave it at that for now. # 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, 2015 at 2:00 # 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, 2015 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. Dec 14, 2015 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, 2015 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. # 68k machine code (EASy68k), 30 bytes 00000000: 303c 000d 43f9 0000 1010 4e4f ffff ffff 0<..C.....NO.... 00000010: 4865 6c6c 6f2c 2057 6f72 6c64 2100 Hello, World!.  I don't know what I'm doing! ## Explanation  ORG$1000
START:                  ; first instruction of program

MOVE #13, D0        ; put text display task number in D0
LEA HELLO, A1       ; load address of string to display into A1
TRAP #15            ; activates input/output task

SIMHALT             ; halt simulator

HELLO DC.B 'Hello, World!',0

END    START        ; last line of source


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