“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

BitShift, 216211 209 bytes

Introducing my first esolang;
BitShift is a language which can only operate on 1 value, and use a limited set of bit-shifting instructions to modify it.
Therefore it's challenging to write programs and it's not great for golfing.

A valid Hello, World! is 209 bytes long, and this is believed optimal. Generated by this metagolf.

10111110111110101001011001001010111011111010011010100101011001000100101011001000001100101011111110011010100101100110010001000100101011110100110110101001000010001010110111101110111101010001000010101111101101010


You can test it here.

Dogescript, 42 37 bytes

plz console.loge with "Hello, World!"


Translates to console.log("Hello, World!").

• plz console.loge with "Hello, World!"is shorter, but admittedly less wow – kvill Aug 31 '15 at 15:21
• Is the plz necessary? I thought you could just console.loge. – Alex A. Sep 2 '15 at 5:59
• @AlexA. doesn't work without plz in the online interpreter, in accordance with the specs – kvill Sep 2 '15 at 19:56
• That's what I was thinking... – LegionMammal978 Sep 3 '15 at 10:57

Simplex, 16 bytes

"Hello, World!"g


g is the standard output mechanism.

• Thanks for using Simplex :D – Conor O'Brien Oct 26 '15 at 11:21

pl, 13 bytes

Hello, World!


Yes, it works. Try it online.

Explanation

In pl, all printable ASCII chars (between 0x20 and 0x7E in CP437) are reserved for variable names. Normally, these chars push the contents of that variable onto the argument stack. BUT, if the variable doesn't actually exist, pl assumes that this is actually the start of a string literal. The string literal is closed when it encounters a variable that exists or a function char. In this case, since none of these variables have been defined, Hello, World! gets pushed onto the stack as a string and printed implicitly at the end.

Whenever, 25 bytes

Whenever is a programming language which has no sense of urgency. It does things whenever it feels like it, not in any sequence specified by the programmer. Since Whenever code is not necessarily executed sequentially, lines of code become more like "to-do" lists, which the language interpreter may tackle in any order it likes.

1 print("Hello, World!");


PlatyPar, 14 bytes

"Hello, World!


In PlatyPar (my language that is still in development), parens, quotes, brackets, etc. are automatically closed at the end of the line. Additionally, the last item on the stack (in this case, "Hello, World!") is implicitly printed.

Try it here!

Acc!!, 122 bytes

Due to limitations of the scoreboard snippet, the title of this post is incorrect. The correct name of this language is Acc!! with italics.

108
Write 72
Write 101
Write _
Write _
Write 111
Write 44
Write 32
Write 87
Write 111
Write 114
Write _
Write 100
Write 33


The first line stores 108 (char code for l) in the accumulator. The rest writes Hello, World! one character at a time, with _ referencing the accumulator value. Using the accumulator beats the straightforward version by 2 bytes. :^)

Works the same in Acc!.

• @quartata Thanks for the edit, but italics in the language name breaks the scoreboard. – DLosc Jan 20 '16 at 22:56
• Ah. Sorry, didn't realize :P – a spaghetto Jan 20 '16 at 23:45
• Maybe the scoreboard snippet should be updated. – mbomb007 Jan 22 '16 at 17:58

VHDL, 98 bytes

entity m is
end;architecture a of m is
begin
process
begin
report"Hello, World";end process;end a;


At least it's not Java...

• class a{public static void main(String[]a){System.out.print("Hello, World!");}} Nope, you've been Java'd. Also this appears to print "Hello World", not "Hello, World!" – CalculatorFeline Mar 25 '16 at 23:56

Verilog, 60 bytes

module m;initial
begin
$write("Hello, World!");end endmodule  • The initial block doesn't need begin & end. – ahmedus Jun 22 at 22:46 Y 16 bytes No, not http://foldoc.org/Y or https://github.com/ConorOBrien-Foxx/Y although we probably need an entry for both of them as well... Y is a stack-oriented FORTH-type programming language by Thomas Fischbacher derived from Wouter van Oortmerssen's "FALSE". Like FALSE, Y is cryptic to the extreme. According to the readme it is much more powerful because "virtually all of the example programs in 'Kernighan & Ritchie - Programming in C' can be done in Y in a fraction of time and code." "Hello, World!"  Kotlin, 50 48 bytes fun main(a:Array<String>)=print("Hello, World!")  Fuzzy Octo Guacamole, 15 bytes "Hello, World!"  This is a new language I created with inspiration from @Conor's NTFJ, @MatinBüttner's Brian and Chuck, and a couple others. It has 2 stacks. This is fairly simple and only uses one stack though. The "..." denotes a string literal that is pushed to the stack. Then implicit output. Pyramid, 587 294 bytes (72)[ no +< ] = a < = np < = (29)[ no +< ] = a < = np +< = a ++++++< = np < = a < = np +< = a ++< = np < = (67)[ no -< ] = a < = np -< = a -----------< = np < = (55)[ no +< ] = a < = np < = (24)[ no +< ] = a < = np < = a +++< = np < = a ------< = np < = a --------< = np < = (67)[ no -< ] = a <  Yikes... this is a monstrosity. This is now less of a monstrosity, but still crazy big for "Hello, World!". The new byte count was because for-loops were implemented in Pyramid (YES!) Pyramid is a stack-based language, which was built on Stackylogic. You should probably go and click on the link before you go to the Github page, because you'll understand the what the commands mean on the GH page better. There's 250 104 lines of code here, if you're interested. • link 404 why :(? – Destructible Lemon Sep 23 '16 at 3:09 • @DestructibleWatermelon Oh yeah, that's because I stopped working on Pyramid. – clismique Sep 23 '16 at 6:40 Processing, 23 bytes print("Hello, world!");  It also opens a window for drawing, but this message does go to stdout in the IDE. I don't understand why more people don't use Processing over Java for code golf. With most of the boilerplate removed, you can almost always outdo it with the same syntax. Codelike, 127 bytes on++++++++n+++n+++**pn++++n+++++++*+ap+++++++pp+++pn++++n++++++++*pfn++n++++*ap________p+++p______p________pn++++n++++++++*+pfe  Try it! *><>, 21 bytes "!dlrow ,olleH"Ool?u;  Try it out on the online interpreter here. *><> (pronounced "Starfish") is an esolang based on ><>, developed by redstarcoder. Its aim is to add some useful features which are missing from base ><>, such as file IO, time functionality, and an interesting feature called 'dive/rise', which is used here. If the 'dive' command, u is encountered, no instructions other than directional modifiers are executed until a 'rise' command, O, is encountered. Encountering a dive whilst already diving, or a rise when not diving, is treated as a no-op. "!dlrow ,olleH"Ool?u; "!dlrow ,olleH" Push "Hello, world!" to the stack in reverse. O Rise - a no-op on first iteration o Output top of stack as ASCII character l?u If length of stack is non-zero, dive ; End program execution  • I love ><> and been interested in *><> so using the dive command for a huge benefit which I haven't seen before is great :) – Teal pelican Dec 19 '16 at 14:47 Pushy, 16 bytes Hello, World!"  Try it online! The first thing to note is that Pushy has no string type. The backticks open/close "stringmode": every character in between has its codepoint (as an integer) pushed to the stack. The " is the print command, which takes all the stack's values, converts them to the corresponding chars, and prints the string. In the very first version, before stringmode was implemented, program looked like this (can probably be golfed more): 72HhH8+&&3+44 32 87 111&3+&6-H33"  It basically just appends the necessary ASCII code points, then prints. DUP, 31 bytes 0$"Hello, World!"\[^^>][$;,1+]#  DUP is a descendant of FALSE, with FALSE being a subset of DUP in most aspects—with a few exceptions. One exception being the way strings are handled. See the FALSE solution in this thread for comparison. In DUP, strings cannot be ouput to STDOUT directly unless the characters are output one by one like this: 'H,'e,'l,'l,'o,',,' ,'W,'o,'r,'l,'d,'!, (this solution would be 39 bytes long)  ' pushes the Integer value of the following character on the data stack. , prints the character according to the integer value on the stack to STDOUT. For shorter strings, this method is usually the shortest way, but in the case of Hello, World! this method is beyond the break even point of the actual string handling method of DUP. 0$"Hello, World!"\[^^>][$;,1+]#  This method successively assigns the characters between both double quotes " to addresses of a cell array, starting at a given address (in this case address 0). In this case, the cells would carry the values 0=72 1=101 2=108 3=108 4=111 5=44 6=32 7=87 8=111 9=114 10=108 11=100 12=33  After assigning the values to the cells, the length of the stored string gets pushed on the stack (in this case 13). The while loop [^^>][$;,1+]# at the end reads out the cell content, starting at 0, prints the according character to STDOUT, increments the counter, and repeats the procedure until the string length 13 is reached.

Try out the solution in this online DUP interpreter or clone my DUP interpreter written in Julia from my GitHub repository, the latter coming with a thorough explanation of all operators.

Whirl, 1350 bytes

I found this Hello, World! example was written by Kang Seonghoon in 2005. I'm including it here for completeness and because I found it helpful along with this visual demonstration of Whirl.

110011100111000001111100000001000011111000011111100000000010
000011001111100001100010000010011111000100000000000001001111
100000111110001000000000000000001000111110010000001100001111
100011000000000100111110011100111000111000001000111000001111
100000111110010000011111000110011111100001111000001111000001
110011111100001111000110011100000111000100011111000001111100
100000110000000111000001110001111100011111000111000001000001
000011000111110001000001000000011100000111001000111110001111
000001111000011111100001111110000011110000000000000000011110
000011100111000011110011111000111110001111100000100000000000
000000000000111110001110000001110000011100011100111110001000
100000000011100001111100110000000010011111000111100000111100
111100010011100000111110000011111001100111100010001111000000
000001000111110010000010011110011001110001000111110001100000
100011111000011110011100111111000111100000111100011111000000
011110000011100100001111000100011111001100011111000111100000
111001110001100111100100000000000000011111000001111100010010
000011100001111100100000100011100000111000110011110001001111
110001100000111100011111000111100000111001000011110001001111
100000111110000000011110000011110000000000000000111000001110
000011000001100000111000111000001100111110000111111001001110
000011111000001100011000001001111110000011100110011111000000
000111000001110000111100001100


"Hello, World!"o


Try it online!

Traffic, 191 bytes

##########################
#+#+#+#+#*#+#+#+#*#*#+#+#+#
#7#9#9#9#3#4#3#8#3#3#9#9#3
#2#9#9#9#7#4#2#7#7#8#9#9#3
#0#2#9#9#3#0#0#0#3#3#9#1#0
#$#$#$#$#$#$#$#$#$#$#$#$#$# C C C C C C C C C C C C C  Traffic is a 2D language modelled after cars moving around streets. Each car holds a value (acting as a variable). This language is as bad at dealing with "strings" as Brainfuck is, so this is kinda bulky. How it works An ungolfed/more "proper" version of the above would look like this: ########################### # # # # # # # # # # # # # # #7#9#9#9#3#4#3#8#3#3#9#9#3# #2#9#9#9#7#4#2#7#7#8#9#9#3# #+#+#+#+#*#+#+#+#*#*#+#+#+# # # # # # # # # # # # # # # #0#2#9#9#3#0#0#0#3#3#9#1#0# #$#$#$#$#$#$#$#$#$#$#$#$#$#

C C C C C C C C C C C C C


In this program, 13 cars are defined: all the digits directly adjacent to a $ (in the #$# constructions) become cars with that initial value. So the program begins with cars that have values 0 2 9 9 3 0 0 0 3 3 9 1 0. The cars' initial directions are away from the $. The streets are defined as the space between #s; #s comprise the walls that cars can't pass through. All the cars move upwards. They pass over the literal, ignoring it because they haven't seen an operator to use yet. Once the reach the top, they'll each see an operator (either + or *). On the next step, they'll all turn around because they hit a dead end. Now when walking back downwards, they will observe the literal, since they have operators to use. After fully walking over each literal (i.e. reaching the start point again), each car performs its operation using the literal and assumes the result of the operation. This results in each car containing the ASCII value of a character in Hello, World!: 72 101 108 108 111 44 32 87 111 114 108 100 33. Then they all step on the $. The $ is a street exit, and one of a few valid characters usable for those. The $ means to output the specified value and destroy the car. The output value for each $ is C, meaning to output the ASCII character given by the car's value. After all cars hit their respective $s, there won't be any cars left in the field. Thus, the program terminates.

PUPPY, 369 bytes

WOOFBARKWOOFBARKWOOFWOOFBARKWOOFBARKWOOFWOOFWOOFWOOFBARKBARKBARKBARKBARK WOOFBARKWOOFBARKWOOFWOOFBARKW OOFBARK  WOO Fwoofbarkbarkwoofwoofwoofwoofwoofwoofwoofwoofwoofbarkwoofwoofwoofbark woofbarkbark BARKWOOFWOOFBARKWOOFBARKBARKWOOFWOOFBARKBARKBARKWOOFBAR KWOOFWOOFBARKBARKBARKWOO FBA rkwoof woofwoof barkbarkbarkwoofbarkwoofbarkwoofwoofbarkwoofbarkbarkbarkwoofwoofbar k


The language that can only be read by puppies.

;# 1142 bytes

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#


;# isn't Turing Complete and doesn't meet the site's standard for a valid language but why not?

; adds one to the accumulator

# outputs the accumulator mod 127

• isn't Turing Complete and doesn't meet the site's standard it does, since this is kolmogorov-complexity. – Erik the Outgolfer May 7 '17 at 17:49
• @EriktheOutgolfer yeah yeah, you know what I mean. – caird coinheringaahing May 15 '17 at 19:14

Ook!, 779 bytes

Ook! Ook! Ook! Ook! Ook? Ook. Ook! Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook! Ook? Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook! Ook! Ook. Ook? Ook! Ook! Ook. Ook? Ook! Ook! Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook? Ook! Ook? Ook. Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook! Ook. Ook! Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook! Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook! Ook.


Based on the shortest Brainfuck Hello World :)

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. – user202729 Feb 2 '18 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. – Potato44 Feb 6 '18 at 22:21 • According to the original site, (and by the number of folders) it is with the comma. I fixed my concise example. – Eran W Feb 7 '18 at 0:44 • Easier way to count: find * -type f | wc -l (counts lines of output) – Peter Cordes Apr 13 '18 at 2:57 • Right, It is shorter by one character... But I could use -lR – Eran W Apr 14 '18 at 8:21 Wumpus, 19 bytes "!dlroW ,olleH"l&o@  Try it online! Introducing the first 2D language on a triangular grid! (Unfortunately, you're not seeing much of that grid in this answer...) Explanation "!dlroW ,olleH" Like in many other Fungeoids, this pushes the individual code points of the string to the stack. l Push the stack depth, 13. &o Print 13 characters. @ Terminate the program.  Forked, 42 bytes 89*@AA*i@7+@@3+@4B*@C'!sF+!@3+@6'@8'!3B*!&  Try it online! AlphaBeta, 68 bytes kjjjggDLeaCLcbbbCLLaaaCLjjjggDLjhhDLsFihhDLCLaaaCLdaaaaCLdaaCLsFiiDL  Try it online! Dodos, 167164160 159 bytes  * 2 1 0 4 L L 1 * 4 3 1 2 1 1 2 2 3 1 * 4 * L + 0 0 4 3 1 1 L 3 1 4 * 2 4 + dot i + j j dip + dab 0 1 i + 0 2 i 1 3 i 2 4 i 3  @Thanks to @Leo for golfing off 1 byte! Try it online! x86/x86_64 on Linux, 34 32 31 bytes 00: e8 0d 00 00 00 call <+0x12> 05: 48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21 "Hello, World!" 12: 59 pop %ecx 13: 6a 01 push$0x1
15:      5b                      pop    %ebx
16:      6a 0d                   push   $0xd 18: 5a pop %edx 19: 6a 04 push$0x4
1b:      58                      pop    %eax
1c:      cd 80                   int    $0x80 1e: c3 ret  Main differences between this one and grc's version: mine makes no assumption of prior register contents, works in both x86 and x86_64 modes and does a ret in lieu of a sys_exit() syscall. If you want to Try it online!, compile and run the following C program. const char main[]="\xe8\r\0\0\0Hello, World!Yj\1[j\rZj\4X\xcd\x80\xc3";  • The difference is that yours is a function, @grc's is code that only works from _start in a static executable (where Linux does give you zeroed registers), and runs sys_exit when it's done. (And BTW, this won't work in 64-bit PIE executables (so your sample caller fails on many recent Linux distros where gcc -pie is the default, or any other context where the code is outside the low 32 bits. int 0x80 truncates pointers to 32 bits) – Peter Cordes Apr 13 '18 at 4:31 • If you make position-dependent code, you could use mov$msg, %ecx (5 bytes) instead of call/pop. Put msg after the ret in your function. You can also save instructions (but not code size) by using lea 3(%ebx), %eax (3 bytes) instead of push/pop, after getting a known value of ebx=1. (Still portable between ia32 and x86-64 with the same machine code, because lea 3(%rbx),%eax is safe. Tips for golfing in x86/x64 machine code). Other than position-dependent mov r32, imm32, I don't see a way to make this shorter. – Peter Cordes Apr 13 '18 at 4:36
• Here's a 30-byte version godbolt.org/g/xAcGMg (position-dependent, and avoiding push/pop in favour of xor-zero/inc and LEA). Note that as a function, it clobbers EBX, thus violating the standard calling convention. That's fine for asm functions, though, but maybe something to mention when you're showing how to use it as a C main. The CRT code that calls main` doesn't actually break if main clobbers EBX on my system, last I checked, but it could. – Peter Cordes Apr 13 '18 at 4:46
• *window subsystem for linux – ASCII-only Apr 17 '18 at 11:10