## "Hello, World!"

462

150

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 {
}
<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>

1Must the language meet our usual requirements for what a programming language is, or are we operating by kolmogorov complexity rules? – isaacg – 2015-08-28T13:54:54.403

2@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 – 2015-08-28T13:56:09.300

6If 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 – 2015-08-28T15:33:49.897

1@aditsu Yes, because there's no way anyone to find to the shortest version in an answer of an unrelated language. – Martin Ender – 2015-08-28T15:39:00.003

Is there a way to make the snippet runnable without having to click "Show code snippet" first? – mbomb007 – 2015-08-28T19:33:18.447

2@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 – 2015-08-28T19:34:40.853

@MartinBüttner About minifying the code, why not minify it with a repeatable minification program, and then include a link to the pre-minified script? – isaacg – 2015-08-29T07:46:03.663

Or the non-minified code could be included in the post in a html comment. – curiousdannii – 2015-08-29T10:27:18.303

Would it be alright for me to answer in my custom esolang that I have not published yet, but have been planning for a few weeks? (I'll only post after I publish it, of course.) It doesn't have any built-ins for "Hello, World!"; the answer will still output it "the hard way". – ETHproductions – 2015-08-29T22:57:55.053

8@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 – 2015-08-29T23:01:10.023

@MartinBüttner Oh, right, didn't catch that the first time. Thanks! – ETHproductions – 2015-08-29T23:01:48.087

This solution of mine causes graphical glitches in the scoreboard when the score is added. – LegionMammal978 – 2015-09-26T14:17:34.547

@LegionMammal978 I'll see if I can do something about it later, but does it really make sense to add a separate Unary solution, if the optimal solution will always be the translation of the optimal BF solution? I think this falls under the "trivial derivatives" bullet point in the spec. – Martin Ender – 2015-09-26T15:09:57.677

Can you assume that there is no input? – LegionMammal978 – 2015-10-03T01:06:43.083

@LegionMammal978 Yes.

– Martin Ender – 2015-10-12T21:29:38.407

1Each submission must be a full program. ... pleace enforce this! Obeying this rule creates a handicap as long as solutions ignoring it are tolerated. – None – 2015-12-24T06:19:16.860

@yeti are they? Could you point me to any that ignore it? I try to keep an eye on all new submissions but at almost 350 answers, occasionally one might slip through the cracks. – Martin Ender – 2015-12-24T07:44:13.923

@MartinBüttner What if the language doesn't have a conventional STDOUT? My preferred language, Mathcad, doesn't have a STDOUT. It is effectively a virtual whiteboard (or sheets of paper) that allows the user to mix text and mathematical expressions, plus graphics, on the "page". Even simply evaluating an expression using the "=" operator causes the output to appear on the "page" (eg, typing "2+2=" results in "2+2=4" appearing). – Stuart Bruff – 2016-03-25T11:06:06.843

1@StuartBruff might be worth asking that on meta, but if stuff appearing on the page is the only way to produce output then I'd call that the closest alternative to STDOUT. – Martin Ender – 2016-03-25T11:14:42.157

2@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 – 2018-05-20T10:20:41.367

484

# Stuck, 0 bytes

Well, can't get shorter than that... An empty program will output Hello, World! in Stuck.

62Damn, i was 20 minutes late! :P – Kade – 2015-08-28T12:55:59.067

38Noooo c'mon fastest gun in the west effect ;) – Beta Decay – 2015-08-28T16:32:10.607

4Wow ! Thats fascinating :) – abhixec – 2015-08-29T06:29:19.417

10@Shebang Did you create the language just so you can win puzzles like this? – Elmo – 2015-09-08T15:26:37.463

41@Zuck Well yes, Stuck was made for code-golfing, just like CJam/GolfScript/Pyth. The Hello, World! thing was just something I had put in as a placeholder early in development. I didn't intend to leave it in so long, just never got around to removing it. – Kade – 2015-09-08T20:34:25.223

151I've been trying to come up with a shorter solution, but I'm stuck. – Cyoce – 2015-12-24T03:40:54.100

15@Shebang 20 minutes, 150+ upvotes. I kinda feel for you – Bassdrop Cumberwubwubwub – 2016-01-07T09:26:33.620

76-1 bytes in jQuery. Have you tried jQuery? – 10 Replies – 2016-12-31T19:36:15.447

@Cyoce How can you have negative quantity? – mekb – 2019-07-17T11:29:03.677

@10Replies how can this be, show me? – Victor VosMottor – 2020-10-13T11:59:52.970

Also a polyglot with Bound – Asher I – 2020-11-10T20:16:30.937

@mekb it's a joke – Makonede – 2021-01-18T16:57:19.713

@Makonede i know lol (imagine commenting on a super old post and you get a response 2 days after lol) – mekb – 2021-01-21T06:51:36.460

@mekb haha yep, i honestly wasn't expecting a response xD – Makonede – 2021-01-21T16:57:18.200

awh i have more rep on codegolf than stackoverflow lmao – mekb – 2021-01-24T04:29:02.320

277

# PHP, 13 bytes

Hello, World!

Yes. It works.

Try it online!

286As usual with PHP, you always wonder how it can work – Fatalize – 2015-08-28T14:03:38.313

104It works, of course, because there's no <?php in the code, causing it not to get interpreted by PHP at all :) – Lynn – 2015-08-28T19:54:54.320

62That means this is just an HTML answer... – Nelson – 2015-08-29T11:42:38.123

91@Nelson no, it doesn't. PHP doesn't necessarily have to be placed in to HTML. And plus, HTML doesn't print to the stdout – galexite – 2015-08-29T11:43:34.897

32This is the most hilarious answer ever – Oliver Ni – 2015-10-16T17:10:22.970

16@Fatalize Let's work on giving the anti-PHP comment more votes than the PHP answer. We're getting closer... – yyny – 2016-01-28T23:13:58.890

1@georgeniux html is just markup. If you want a "program" to "run" html you could do alias html=cat and then it outputs to stdout. – Marcel – 2016-11-14T12:51:56.423

6This is an html answer. it's lame to call it php. You'd get the same thing for the same reason in any template language. It's pugs/mason/template toolkit too! – Evan Carroll – 2017-03-29T00:24:56.857

9trying this out via CLI with php -r "Hello, World!" results in an error. – phil294 – 2017-06-04T06:45:15.143

2@YoYoYonnY Success has been achieved :P – HyperNeutrino – 2017-06-17T02:38:56.527

9See, when I did this, I got a -1, not +173 – Stan Strum – 2017-09-02T17:37:44.990

@StanStrum Because then it would be a duplicate of this answer – MilkyWay90 – 2019-08-23T16:23:03.303

@MilkyWay90 I vaguely remember the context of this (being about 2 years ago) but I had written a similar answer to a similar question and received a -1. Not on this question, being not a duplicate. – Stan Strum – 2019-08-23T20:59:14.583

Well, it seems to work at least at ideone.com, outputting Hello, World! to stdout.

– hyde – 2019-08-29T14:50:57.510

2Contrary to several comments here, there is no HTML in this answer, and no "HTML mode" in PHP. This is source code, executable by PHP, which is precisely equivalent to <?php echo 'Hello, World!'; ?>, because the language's author decided that it should be. From a compiler's point of view, it's just as accurate to say that <?php is an "end echoed string literal" marker as a "begin PHP code" marker, with ?> then being an "echo another string literal" marker. – IMSoP – 2020-07-02T16:56:29.110

263

# Brainfuck, 78 bytes

Open-ended bounty: If anyone can improve this score, I will pass the bounty (+500) on to them. @KSab has found a 76 72 byte solution!

--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.

Try it online!

The first 28 bytes --<-<<+[+[<+>--->->->-<<<]>] initialize the tape with the following recurrence relation (mod 256):

fn = 171·(-fn-1 - fn-2 - fn-3 + 1), with f0 = 57, f1 = 123, and f2 = 167.

The factor of 171 arises because 3-1 ≡ 171 (mod 256). When the current value is translated one cell back (via <+>---) subtracting 3 each time effectively multiplies the value by 171.

At n = 220 the value to be translated is zero, and the iteration stops. The ten bytes preceding the stop point are the following:

[130, 7, 43, 111, 32, 109, 87, 95, 74, 0]

This contains all of the components necessary to produce Hello, World!, in hunt-and-peck fashion, with minor adjustments.

I've also found an alternative 78 byte solution:

-[++[<++>->+++>+++<<]---->+]<<<<.<<<<-.<..<<+.<<<<.>>.>>>-.<.+++.>>.>-.<<<<<+.

Try it online!

I consider this one to be better than the first for several reasons: it uses less cells left of home, it modifies less cells in total, and terminates more quickly.

### More Detail

Recurrence relations have surprisingly terse representations in Brainfuck. The general layout is the following:

{...s3}<{s2}<{s1}[[<+>->{c1}>{c2}>{c3...}<<<]>{k}]

which represents:

fn = c1·fn-1 + c2·fn-2 + c3·fn-3 + ... + k

with

f0 = s1, f1 = s2 + c1·f0 + k, f2 = s3 + c2·f0 + c1·f1 + k, etc.

Additionally, the <+> may be changed to multiply the range by a constant without affecting the stop point, and a term may be added before the >{k} to shift the range by a constant, again without affecting the stop point.

### Other Examples

Fibonacci Sequence

+[[<+>->+>+<<]>]

N-gonal Numbers

Triangular Numbers

+[[<+>->++>-<<]>+]

Defined as fn = 2·fn-1 - fn-2 + 1, with f0 = 0, f1 = 1.

Square Numbers

+[[<+>->++>-<<]>++]

Pentagonal Numbers

+[[<+>->++>-<<]>+++]

etc.

### BF Crunch

I've published the code I used to find some of this solutions on github. Requires .NET 4.0 or higher.

Usage: bfcrunch [--options] text [limit]

Arguments
------------------------------------------------------------
text              The text to produce.
limit             The maximum BF program length to search for. If zero, the length of the
shortest program found so far will be used (-r). Default = 0

Options
------------------------------------------------------------
-i, --max-init=#  The maximum length of the initialization segment. If excluded, the
program will run indefinitely.
-I, --min-init=#  The minimum length of the initialization segment. Default = 14
-t, --max-tape=#  The maximum tape size to consider. Programs that utilize more tape than
this will be ignored. Default = 1250
-T, --min-tape=#  The minimum tape size to consider. Programs that utilize less tape than
this will be ignored. Default = 1
-r, --rolling-limit
If set, the limit will be adjusted whenever a shorter program is found.
-?, --help        Display this help text.

Output is given in three lines:

1. Total length of the program found, and the initialization segment.
2. Path taken, starting with the current tape pointer. Each node corresponds to one character of output, represented as (pointer, cost).
3. Utilized tape segment.

For example, the final result for bfcrunch "hello world" 70 -r -i23 is:

64: ++++[[<+>->+++++>+<<]>]
49, (45, 5), (44, 3), (45, 6), (45, 1), (45, 4), (42, 4), (43, 5), (45, 3), (45, 4), (46, 2), (44, 4)
32, 116, 100, 104, 108, 132, 0, 0, 132, 0

This corresponds to the full program:

++++[[<+>->+++++>+<<]>]<<<<.<+.>++++..+++.<<<.>+++.>>.+++.>.<<-.

### Other Records

Hello, World!

Wrapping, 78 bytes:

--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.

or

-[++[<++>->+++>+++<<]---->+]<<<<.<<<<-.<..<<+.<<<<.>>.>>>-.<.+++.>>.>-.<<<<<+.

Non-wrapping, 87 bytes (previously 92 bytes (mitchs)):

--->->->>+>+>>+[++++[>+++[>++++>-->+++<<<-]<-]<+++]>>>.>-->-.>..+>++++>+++.+>-->[>-.<<]

Hello, world!

Wrapping, 80 bytes:

++<-[[<+>->+>--->-<<<]>+++]>+.<<<<<<<++.>>>..>.<<--.<<<--.>>+.>>>.+++.<.<<<-.<+.

Non-wrapping, 81 bytes (previously 92 bytes (hirose)):

+>---->->+++>++>->+[++++++++[>++++++++>>+++++<<<-]<]>>.>++>.>..+>>.+>-->--[>-.<<]

hello, world!

Wrapping, 74 bytes:

-<++[[<+>->->+++>+<<<]->]<<.---.<..<<.<<<---.<<<<-.>>-.>>>>>.+++.>>.>-.<<.

Non-wrapping, 84 bytes:

---->+++>++>->->++[+++++++[>+++++[>++>>+<<<-]<-]++<]>>>>.---.>---..+>->.+>-->+>[-.<]

### Esolangs Version

Hello World!\n

Wrapping, 76 bytes:

+[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.[<]>+.

This uses one cell left of home, and thus would be considered 77.

Non-wrapping, 83 bytes:

->+>>>+>>---[++++++++++[>++++++>+++>+<<<-]-<+]>+>+.>.->--..>->-.>[>.<<]>[+>]<<.>++.

Rdebath approved. profilebf output:

Hello World!
Program size 83
Final tape contents:
:   0   0  73 101 109 115 112  88  33  10   0
^
Tape pointer maximum 10
Hard wrapping would occur for unsigned cells.
Counts:     +: 720          -: 79           >: 221          <: 212
Counts:     [: 9            ]: 84           .: 13           ,: 0
Total:         1338

### inversed.ru (Peter Karpov)

Hello World!

Wrapping, 70 bytes (previously 781):

+[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.

Non-wrapping, 77 bytes (previously 89?):

->+>>>+>>-[++++++[>+++++++++>+++++>+<<<-]<+]>>.>--.->++..>>+.>-[>.<<]>[>]<<+.

The author claims that the shortest hand-coded "Hello World!" is 89 bytes, but provides no reference. I hereby claim the record for this, too.

hello world!

Wrapping, 65 bytes (previously 66 bytes):

+++[>--[>]----[----<]>---]>>.---.->..>++>-----.<<<<--.+>>>>>-[.<]

This is actually hand-coded as well (the best I could find by crunching is 68 bytes). The first cell is initialized to 259 (3), and decremented by 7 each iteration, looping 37 times. The next cell is decremented by 6, resulting in 256 - 6·37 = 34. The rest of the cells are decremented by 4 each time, adding one cell each iteration, with each new cell inialized to 252 (-4). The result is the following:

[  3,   0,   0,   0,   0,   0,   0, ...]
[252, 250, 248,   0,   0,   0,   0, ...]
[245, 244, 244, 248,   0,   0,   0, ...]
[238, 238, 240, 244, 248,   0,   0, ...]
[231, 232, 236, 240, 244, 248,   0, ...]
[224, 226, 232, 236, 240, 244, 248, ...]
...
[ 35,  64, 124, 128, 132, 136, 140, ...]
[ 28,  58, 120, 124, 128, 132, 136, ...]
[ 21,  52, 116, 120, 124, 128, 132, ...]
[ 14,  46, 112, 116, 120, 124, 128, ...]
[  7,  40, 108, 112, 116, 120, 124, ...]
[  0,  34, 104, 108, 112, 116, 120, ...]

1 The solution given (79 bytes) can be trivially reduced by one:

-[>>+>+[++>-<<]-<+<+]>---.<<<<++.<<----..+++.>------.<<++.>.+++.------.>>-.<+.

5This is great! Got the small-w version down to 82 :) +>---->->+++>++>->+[++++++++[>++++++++>>+++++<<<-]<]>>.+>++>.>..+>>.+>-->--[>-.<<] – Mitch Schwartz – 2016-01-03T17:26:45.640

43This is nuts. One of you should submit the 82-byte version to anarchy golf. – Martin Ender – 2016-01-03T17:43:29.320

130The best Java solution to this question is 76 bytes. Only 9 more bytes to go to prove Java developers should switch to Brainfuck. – Level River St – 2016-01-03T21:51:12.523

14@LevelRiverSt The small-letters one is 2 bytes shorter than Java. The endtimes have come. – Conor O'Brien – 2016-04-13T13:59:07.103

6Awesome work Primo! @CᴏɴᴏʀO'Bʀɪᴇɴ the edit was on Jan 29, nearly 4 weeks after my previous comment, and the world has not ended. Remember the fuss about Millenium Bug back in late 1999, and nothing happened in 2000? Just like then, the world remains the same, and developers are STILL using Java. WTF! – Level River St – 2016-04-13T15:52:55.573

14"Only 9 more bytes to go to prove Java developers should switch to Brainfuck." interface a{static void main(String[]A){System.out.print("No!");}} – dorukayhan – 2016-06-11T01:10:20.893

1

Sorry to break dreams, but Java got really ahead...

– Olivier Grégoire – 2017-08-23T09:35:25.477

@dorukayhan main(){puts("Hahaha");} – Stan Strum – 2018-04-09T06:19:12.427

6

@primo 76 bytes! https://codegolf.stackexchange.com/a/163590/15858

– KSab – 2018-04-27T14:59:37.510

@OlivierGrégoire that's a really outdated version of Java though, who uses that in production anymore :P – ASCII-only – 2018-05-06T00:53:01.857

2@ASCII-only I know a few companies... – Olivier Grégoire – 2018-05-06T11:50:20.747

238

# ArnoldC, 71 bytes

IT'S SHOWTIME
TALK TO THE HAND "Hello, World!"
YOU HAVE BEEN TERMINATED

Just for lols...

Try it online!

4Worked for me. Try putting it's showtime on the first line and you have been terminated on the last line – JelloDude – 2015-08-28T14:55:52.753

85I really need to learn how to use this language. – Buzz – 2015-08-31T14:29:27.150

3Doesn't a space and a newline take up the same number of bytes? And technically, IT'S SHOWTIME and TALK TO THE HAND should be on the first and last lines. – wizzwizz4 – 2015-12-29T10:33:06.643

3@wizzwizz4 It worked for me like this :D – AlCode – 2016-09-06T11:29:23.600

7@AlCode But it's more correct and takes up the same number of bytes and there is more compatibility and it looks nicer and why am I making a fuss this is a code golf challenge on PPCG and it is a surprise that your code is readable and well done you made a well golfed answer that was readable and +1. – wizzwizz4 – 2016-09-06T15:36:49.070

13@wizzwizz4 thank your very much, I try to be as professional as possible with ArnoldC the language of the future! – AlCode – 2016-09-08T11:59:38.893

1

The string should be Hello, World!

– Jo King – 2020-08-04T10:30:53.973

225

# Seed, 60164234 4203 bytes

20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793

Try it online! The resulting Befunge-98 program (based on this) is

"9!dlroW ,olleH"ck,@

5Very impressive! According to the spec and reference implementation on esolangs, the 21 should come first though. As is, this tries to generate a Befunge program with 10⁶⁰¹¹ characters. – Dennis – 2016-10-28T15:00:36.883

6@Dennis Oops LOL. – feersum – 2016-10-28T15:02:33.343

39Wow! How did you find this? – ETHproductions – 2016-10-28T15:04:34.003

3@ETHproductions I'll probably want to see if I can make the seed shorter than the length of the PRNG's state vector before I do an explanation. – feersum – 2016-10-28T15:07:30.857

34What. That's insane. – Conor O'Brien – 2016-10-31T14:33:59.153

55HOW DID YOU GOLF THIS? – Destructible Lemon – 2016-10-31T23:55:28.243

52Did you reverse engineer the mersenne twister? And does this have any security implications? – primo – 2016-11-01T14:37:54.050

6Given the size of the number and the fact that feersum was able to golf it down, this is almost certainly an abuse of some mechanic about the mersenne twister, but I'll leave feersum to answer the second question. – Zwei – 2016-11-02T12:48:18.117

2Inquiring minds want to know ! – Aaron – 2016-11-03T14:43:54.530

2@feersum We demand to know. – Buffer Over Read – 2016-11-05T18:41:56.360

9I was actually about to start work on this lol. The MT is entirely linear. It isn't a Cryptographically Secure PRNG, so it is possible to reverse a desired output back to a seed. – Liam – 2016-11-05T19:13:27.030

2

@Liam If you're still interested in the problem, you could try to crack this.

– feersum – 2016-11-05T20:23:09.833

78I'll give you another +500 for a detailed (theoretical) explanation. – primo – 2016-11-14T12:51:04.370

2

I've read this before, but his method needs 624 samples. I'd like to see how feersum did it as well.

– mbomb007 – 2016-12-01T22:09:36.303

Is it possible to output a quote? It doesn't seem easy as there is a second loop in init_by_array.

– jimmy23013 – 2017-01-02T22:23:10.687

21I think I'll pitch in +250 along with @primo – Conor O'Brien – 2017-01-22T23:51:29.367

9@ConorO'Brien As will I – NoOneIsHere – 2017-05-16T00:18:11.893

9Trying to golf this... Estimated time: 511576891064129323642698858496 days, 18 hours – Christopher – 2017-06-02T23:24:26.747

4My solution is 6014 bytes. :( This was a fun challenge to attempt. For anyone interested in how he managed to get this answer, take a look at Python's source code on GitHub. You'll be interested in _randommodule.c, random(), and init_by_array() – TehPers – 2017-07-28T16:35:19.980

5Explanation plz!! – NoOneIsHere – 2017-08-02T06:24:08.230

3Please. How did you do this?!?!?!?!?! – wizzwizz4 – 2017-12-17T09:28:13.587

4 start="2018">

• Still no explanation. I'm beginning to lose hope :(
• < – betseg – 2018-04-08T21:53:37.520

8Essentially he took advantage of the fact that the Mersenne Twister is not a one-way random number generator (this is part of why it is not cryptographically secure). There are no security implications of this answer.

More detailed: You can generate 624 integers to create the state of the Mersenne Twister, then generate the seed from that. He presumably kept generating integers until he found the string he was looking for (in this case the Befunge code above, then generated the seed for the 624 integers before it, which is posted above. Repeated searches is how he reduced the seed. – Spenser Truex – 2018-04-15T21:35:55.723

3@SpenserTruex This is not a good description of my algorithm. – feersum – 2018-04-15T23:34:38.420

22@feersum Then why not give one? ;) – musicman523 – 2018-05-05T03:36:33.780

9I guess it's because feersum likes to get these monthly reminders that he/she is smarter and wiser than everyone else... :) – Stewie Griffin – 2018-07-08T18:22:17.110

1@SpenserTruex I can't speak for this solution, but mine at least generates the 624 states by taking the expected output of the random number generator (padded with however many characters are needed to use 624 states in total), then reversing all the operations done by the random number generator. Since each character output accounts for two states in the generator, mine pads the expected output to 312 characters and reverses it to its states from there. I don't know how feersum golfed this though, or if that's even the same process used here. – TehPers – 2018-08-09T17:35:14.817

1Please, we need an explanation. I'm starting to think that you secretly reverse-engineered the Mersenne Twister and think that humanity is not ready for it and that telling it will make the world go into chaos – MilkyWay90 – 2018-11-16T02:30:29.263

@TehPers how did you get the states? – MilkyWay90 – 2018-11-16T02:35:26.480

4

For the sake of feersum's inbox, here's my (slightly broken) implementation of a Befunge-to-Seed converter. I would love to see the code used to generate this solution, but it seems like we won't get to view it anytime soon. For anyone interested in creating one on their own, you'll want to write a function that takes the expected output of the Mersenne Twister, converts it to the states that represent that output, then take a look at how the seed is used to generate those states to reverse it to the original seed. Have fun!

– TehPers – 2018-11-22T02:43:00.743

This could actually be useful for my programming language – MilkyWay90 – 2019-03-01T23:16:27.520

5

Outgolfed: https://codegolf.stackexchange.com/a/191482/61379 Update: Now my answer is 68 digits less!

– Kamila Szewczyk – 2019-09-10T14:59:56.423

169

## Mornington Crescent, 3614 3568 bytes

Thanks to NieDzejkob for saving 46 bytes by using shorter line names.

Take Northern Line to Hendon Central
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Gunnersbury
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Acton Town
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Mile End
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Mile End
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Central Line to Holborn
Take Central Line to Mile End
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Barking
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Barking
Take District Line to Gunnersbury
Take Circle Line to Wood Lane
Take Circle Line to Victoria
Take Circle Line to Victoria
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Mile End
Take Central Line to Fairlop
Take Central Line to Mile End
Take District Line to Barking
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Mile End
Take District Line to Gunnersbury
Take Circle Line to Hammersmith
Take District Line to Mile End
Take District Line to Richmond
Take District Line to Mile End
Take District Line to Richmond
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Stepney Green
Take District Line to Hammersmith
Take District Line to Stepney Green
Take District Line to Upney
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Upney
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Try it online!

This is most certainly suboptimal, but it's half the size of the solution on esolangs.

Hello, World is constructed via slicing the following station names and concatenating the results:

Hendon Central
▀▀
▀▀▀
Heathrow Terminals 1, 2, 3
▀▀
Wood Lane
▀▀
Fairlop
▀▀
Richmond
▀

Finally, I'm computing the character code of ! as (2<<4)+1 == 33. All these parts are concatenated in Paddington and finally printed in Mornington Crescent.

Note: The language doesn't specify whether it's possible to travel to same station twice in a row, but the interpreter does allow it, so I've made use of it.

49This is absolutely brilliant :D – Beta Decay – 2015-09-04T18:03:31.857

37I love this language. Excuse me, while I do systems programming in this language. – cat – 2015-12-20T03:46:02.080

6Where on EARTH has this language been all my life? – ScottMcGready – 2017-07-11T23:04:54.437

38@ScottMcGready between Camden Town and Euston. – Martin Ender – 2017-07-12T11:25:56.957

5

Mornington Crescent is on TIO now. https://tio.run/#mornington-crescent

– Dennis – 2017-09-13T03:13:27.880

Pushing this to production... – arodebaugh – 2018-02-02T18:37:46.607

3572 bytes – NieDzejkob – 2018-03-10T16:00:59.010

@NieDzejkob what did you golf? Is it just some minor changes? – Martin Ender – 2018-03-10T16:05:23.753

@MartinEnder just using shorter Line names where possible – NieDzejkob – 2018-03-10T16:18:24.213

@NieDzejkob ah, right. I actually wrote a script for that when doing the primality test. I might see how short it gets using that if I can be bothered to understand the code again. – Martin Ender – 2018-03-10T17:00:16.260

@MartinEnder I believe you've misunderstood what I've done. Your script finds intermediate stations, mine finds shortest line names. I wrote a script to do this to get 3568 bytes.

– NieDzejkob – 2018-03-15T16:50:29.290

@NieDzejkob Actually, I misremembered what my script does. I thought it just computes the overall golfiest path (including intermediate stations and lines), but apparently it only looks at the length of station names and leaves the rest up to the programmer. – Martin Ender – 2018-03-15T17:11:58.220

What the heck is this language? – AJFaraday – 2018-03-15T19:28:05.800

Do I recognise the names of the London Underground "tube" lines?! xD – ΛRYΛN – 2020-11-19T10:05:42.553

132

# brainfuck, 72 bytes

+[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.

Try it online!

And the original non-wrapping 76 byte solution:

+[+[<<<+>>>>]+<-<-<<<+<++]<<.<++.<++..+++.<<++.<---.>>.>.+++.------.>-.>>--.

Try it online!

### Other shortest known (to my knowledge) solutions I've found

'Hello, world!' 77 bytes:

+[+++<+<<->>>[+>]>+<<++]>>>>--.>.>>>..+++.>>++.<<<.>>--.<.+++.------.<<<-.<<.

Try it online!

'hello, world!' 70 bytes:

+[>>>->-[>->----<<<]>>]>.---.>+..+++.>>.<.>>---.<<<.+++.------.<-.>>+.

Try it online!

These were found using a c++ program I wrote here: https://github.com/ksabry/bfbrute

Note: I originally wanted to clean up this code before I posted it to make it actually somewhat readable and usable, but since I haven't gotten around to it in over a year I figure I'll just post it as is. It makes heavy use of templates and compile time constants for any potential optimizations and it has a bunch of commented out code from my testing but no helpful comments so sorry but it's a bit horrible.

There is nothing terribly clever about the code, it's brute forcer at it's core, however it is quite optimized. The major optimization is that it first iterates through all programs without loops (no [ or ]) up to a specified length (16 currently) and caches an array of all the changes it will make on the data array. It will only store a single program per unique array of changes so for example only one of >+<<-> and <->>+< will be stored. It then iterates through all possible programs which are composed of any program in this cache with any combination of loops between them. After executing each program it does a simple greedy hunt and peck for the characters and appends this to the end of the program.

After running this through the space of all programs I noticed that almost all the shortest programs (up to length ~19) were of the form *[*[*]*]. Restricting the search to programs of this form sped up the search considerably. The current record holder was found at length 27. This one was actually computed to be length 74, but I noticed a particular sequence .>.>.>. which was lucky enough to have a 0 in the data cell to it's right allowing it to be simplified to [.>]< bringing it down to 72.

I let it run for quite awhile and completed the search with the current parameters up to length 29, I suspect it will be difficult to beat the current one by simply going higher, I think the most promising approach would probably be increasing the search space in some intelligent way.

33How on Earth did you find this? – Dennis – 2018-04-27T18:50:33.367

2@Dennis I will probably post an explanation of my process when I get the chance, along with the source code I used (once I clean it up) – KSab – 2018-04-27T19:00:16.093

40Hey you beat Java. – Poke – 2018-04-27T19:20:13.140

@KSab I wonder if this is optimal – ASCII-only – 2018-04-28T02:36:22.697

19That's some device, it doesn't even require wrapping cells ó_Ò – primo – 2018-04-28T12:08:47.707

This is extremely impressive! For reference, the initialization loop leaves the tape as ...35 42 87 106 99 72 35 (0)... – Esolanging Fruit – 2018-04-28T17:41:13.483

5Would love to see the algorithm behind this :) – musicman523 – 2018-05-05T03:40:18.967

Are those other shortest solutions from a source that is not your brain? If so, can you post those sources? – Engineer Toast – 2018-05-09T16:33:40.357

1@EngineerToast sorry for the unclear wording, I did find those using the same method as the main solution – KSab – 2018-05-09T16:43:21.503

– Olivier Grégoire – 2018-05-31T22:02:26.657

1Explain! (please.) – 3D1T0R – 2018-06-07T00:54:17.463

1I like how this uses a loop even during the "find and print" second half of the program. – LyricLy – 2018-06-19T01:24:16.813

1When are you going to explain it :P – ASCII-only – 2018-12-14T11:57:44.397

We want an explanation! – Esolanging Fruit – 2019-04-20T03:37:48.573

1@EsolangingFruit I've been busy and honestly sort of forgot about this. It might not be too in depth but this weekend I think I'll make some time to write an explanation and upload the source code. – KSab – 2019-04-20T15:33:48.807

130

# evil, 70 bytes

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Try it online!

It uses the following four commands:

a - increment the register
u - decrement the register
e - interweave the register's bits (01234567 -> 20416375)
w - write the value of the register as an ASCII character

65That is evil... – David says Reinstate Monica – 2015-09-01T14:18:35.230

67Especially since your avatar is Black Hat. – TheDoctor – 2015-09-01T23:47:22.060

5can u explain me the interweave process. – Kishan Kumar – 2015-11-04T14:25:48.293

2@KishanKumar the register is one byte. Its 8 bits, bit 0 to bit 7, are reordered to form a new byte: (bit 2, bit 0, bit 4, bit 1, bit 6, bit 3, bit 7, bit 5). – grc – 2015-11-04T14:58:41.420

4

@KishanKumar yes

– grc – 2015-11-04T16:12:32.583

1@grc thanks. Any offline compiler will also be great – Kishan Kumar – 2015-11-05T14:15:14.893

3

@KishanKumar there's a java implementation here.

– grc – 2015-11-05T15:58:08.773

34If you read this program out loud, it sounds like a dubstep bass. – Joe Z. – 2016-06-17T15:04:21.227

88

# Piet, 90 codels

This is a 30 by 3 image. Alternatively, at codel size 10:

The uses a 3-high layout so that I only need to pointer once. If this is still golfable I could probably shave at most another column, since there's a push-pop no-op in there.

6Trying to take your own bounty? I thought more of you Sp3000 ;) – Beta Decay – 2015-09-02T11:18:09.560

7Hah, just because I set a bounty doesn't mean I can't join in the fun :P – Sp3000 – 2015-09-02T11:29:50.800

Have a +1 anyway. I love Piet – Beta Decay – 2015-09-02T11:34:07.143

This is the smallest Piet "Hello, World!" that I've seen. – mbomb007 – 2015-09-02T16:16:03.803

Great job! I’m trying to find a smaller solution, although I doubt I’ll be able to. Yeah, pointering is a pain in the butt. – M L – 2015-09-02T19:35:40.763

Nice! My Piet solution was the shortest one for a good half hour that's already something I guess :) Have you tried redrawing it with the first codel in the upper left corner black? (you won't have to rotate the pointer at all then). – plannapus – 2015-09-03T07:30:22.733

@plannapus I saw yours and thought about doing that, but as far as I can tell from the spec that's undefined behaviour, and in particular the interpreter I'm using doesn't do anything if the top left is black... – Sp3000 – 2015-09-03T07:33:13.603

oh i didn't realize it was, as I always used PietDev. – plannapus – 2015-09-03T07:34:31.327

PietDev does not behave according to the specification, at least not in all respects. One major flaw is that PietDev does not work with integers once you use the DIV operation, which produces floating point values as a result. That’s why I always check my results with npiet. – M L – 2015-09-03T13:34:38.500

@plannapus one can, however, put a black codel on the second row, with largely the same effect: http://codegolf.stackexchange.com/a/67601

– primo – 2015-12-27T06:47:34.607

10

A push-pop isn't a no-op to me. It's this.

– mbomb007 – 2016-02-24T19:46:57.763

1What the hell is this "language"? I love it! – Zoltán Schmidt – 2016-10-11T12:50:57.093

8"push-pop no-op" is now my favourite phrase – BobTheAwesome – 2017-01-20T22:27:38.487

1Modern international spies must use this language. – Kzqai – 2017-03-08T03:39:35.887

You should be able to consider one codel equals 3 bytes, right? There are 2 bytes for x and y and one byte for the color. – univalence – 2017-04-23T17:34:50.503

@MegaMan Base 18 encoding would take 47 bytes, plus 2 bytes for dimensions makes 49. A better compression probably exists. – primo – 2017-06-12T12:12:56.907

TIO.run allows you to use piet can you add a tio.run?

– None – 2020-03-24T10:26:59.100

87

# Haystack, 17 Bytes

Haystack is a 2D programming language that executes until it finds the needle in the haystack |, all while performing stack-based operations. All programs start from the top left corner, and can use the directional characters ><^v to move around the program. Direction is inherited, so you do not need to keep using > to go right, direction will only change when it hits a different directional character.

By default, the interpreter reads from the top left going right, so we can just put "Hello, World!" onto the stack, use o to print it, then place the needle to finish executing.

"Hello, World!"o|

Bonus: A more exciting version:

v      >;+o|
v      "
v      !
v      d
v      l
v      r
>>"Hello, ">>>v
W      v
"      v
^<<<<<<<

Just out of curiosity, what happens if you include one of the characters in a string? – Random832 – 2015-08-28T16:34:49.447

@Random832 In a string, directional characters are treated as regular characters, i.e. you can include them in a string. – Kade – 2015-08-28T17:23:12.613

Is there somewhere a detailed description or specification of the language? In particular I'm interested, what happens if you "step" on a whitespace? – Kritzefitz – 2015-08-28T19:31:11.373

@Kritzefitz I haven't written an official spec, but whitespace will preserve the direction that was used to travel to it. So, if your program is using right, it will continue right on a whitespace or a noop. – Kade – 2015-08-28T21:01:58.600

Most entertaining solution here; this one wins. – MrDuk – 2015-09-03T03:41:30.167

45ockquote>

;+o​​​​​​​​​​​

– bjb568 – 2015-09-13T00:10:53.430

3I wish I was half as smart as everyone here, but in the "documentation" (read: some guy's forum post) it says o outputs as a number. Shouldn't it be c at the end? Is there proper documentation anywhere? This is super interesting! – JOATMON – 2016-01-15T15:49:32.570

3@Scott Super late to reply to this, that forum post was probably me! o outputs the top stack item as-is, i.e. if a number is there it prints that. c would simply cast that to a char. So, if you have a string or char on the top of the stack o would be what you want :) Eventually these docs will be updated.. – Kade – 2016-10-03T13:17:55.823

76

# Help, WarDoq!, 1 byte

H

Not only does Help, WarDoq! have a built-in for most common spellings of the phrase, it even satisfies our usual definition of programming language.

Try it in the official online interpreter (code goes in Input).

1Hahaha well done for creating the most useful golfing language ever :D – Beta Decay – 2015-08-28T13:50:51.907

7So, HQ9++, essentially, eh? ;-) – AdmBorkBork – 2015-08-28T13:52:30.973

6

@TimmyD Nope, not HQ9++.

– Dennis – 2015-08-28T13:58:24.827

31Oh for crying out loud. Is there anything that isn't an esolang at this point? :) – AdmBorkBork – 2015-08-28T14:22:20.947

114"Space: Begin a comment. The next non-space character ends the comment and is interpreted as usual." So you can only have comments made of spaces then??? I suppose even the most useful language in the world has to have one unuseful feature +1, – Level River St – 2015-08-29T18:44:42.073

33

@steveverrill Maybe if tabs are also considered as comments, then we can have the comments written as Whitespace programs

– Optimizer – 2015-09-03T19:12:05.730

3And in which way the space is explicitly stated as character for comments, while it states any unkown character is ignored? doesn't it resolv to the same?! – Zaibis – 2015-09-07T14:24:38.197

3@LevelRiverSt I was going to upvote your comment, but it has 42 upvotes. – gcampbell – 2016-05-20T19:02:58.897

@LevelRiverSt Who says you can't encode comments in unary? Number of spaces in it's binary representation split into chunks of eight pieces all converted to base-10 and take each of their Unicode character equivalents, than you have your comment! It's as simple as that. – MilkyWay90 – 2019-03-30T23:03:47.783

69

# MarioLANG, 259249242240 235 bytes

+>+>)+)+)+++)++++((((-[!)>->.
+"+"===================#+".")
+++!((+++++++++)++++++)<.---+
++=#===================")---.
++((.-(.)).+++..+++++++.<---
!+======================---
=#>++++++++++++++.).+++.-!>!
=======================#=#

This has been tested in the Ruby implementation.

After obfuscating "Hello, World!" in MarioLANG I looked into golfing it a bit. The above is the shortest I have found so far.

As before I started from a Brainfuck solution which sets four cells to the nearest multiple of 10 to the characters He, and space and converted it to MarioLANG. You can then shorten the code a bit by making use of the auxiliary floor in the loop which almost halves the width of the loop. Note that the bottom is only executed one time less than the top, so you don't get exact multiples of the initial counter in all 4 cells any more.

Finally, I wanted to make use of the wasted space in front of the loop, so I added a bunch of elevators to make use of the vertical space there. And then I realised that I could fold the code after the loop (see previous revision) below the loop to make use of some more vertical space, which saved five more bytes.

This is likely still far from perfect, but it's a decent improvement over the naive solution, I think.

## Metagolf

Time for some automation...

I have started setting up a solver in Mathematica to find an optimal solution. It currently assumes that the structure of the code is fixed: counter set to 12, 4 cells for printing, with the fixed assignment to He,<space> and the same order of those cells. What it varies is the number of +s in the loop as well as the necessary corrections afterwards:

n = 12;
Minimize[
{
3(*lines*)+
12(*initialiser base*)+
8(*loop ends*)+
18(*cell moves*)+
26(*printing*)+
43*2(*steps between letters in one cell*)+
-2(*edge golf*)+
4 Max[4 + a + d + g + j + 2 Sign[Sign@g + Sign@j] + 2 Sign@j + 2,
4 + b + e + h + k + 2 Sign[Sign@h + Sign@k] + 2 Sign@k] +
2 (Abs@c + Abs@f + Abs@i + Abs@l),
a >= 0 && d >= 0 && g >= 0 && j >= 0 &&
b >= 0 && e >= 0 && h >= 0 && k >= 0 &&
n*a + (n - 1) b + c == 72 &&
n*d + (n - 1) e + f == 101 &&
n*g + (n - 1) h + i == 44 &&
n*j + (n - 1) k + l == 32
},
{a, b, c, d, e, f, g, h, i, j, k, l},
Integers
]

It turns out, that for an initial counter of 12 my handcrafted solution is already optimal. However, using 11 instead saves two bytes. I tried all counter values from 6 to 20 (inclusive) with the following results:

6: {277,{a->7,b->6,c->0,d->16,e->1,f->0,g->0,h->9,i->-1,j->0,k->6,l->2}}
7: {266,{a->6,b->5,c->0,d->11,e->4,f->0,g->2,h->5,i->0,j->0,k->5,l->2}}
8: {258,{a->2,b->8,c->0,d->3,e->11,f->0,g->5,h->0,i->4,j->4,k->0,l->0}}
9: {253,{a->8,b->0,c->0,d->5,e->7,f->0,g->2,h->3,i->2,j->0,k->4,l->0}}
10: {251,{a->0,b->8,c->0,d->3,e->8,f->-1,g->4,h->0,i->4,j->3,k->0,l->2}}
11: {240,{a->1,b->6,c->1,d->1,e->9,f->0,g->4,h->0,i->0,j->3,k->0,l->-1}}
12: {242,{a->6,b->0,c->0,d->6,e->3,f->-4,g->0,h->4,i->0,j->0,k->3,l->-1}}
13: {257,{a->1,b->5,c->-1,d->6,e->2,f->-1,g->3,h->0,i->5,j->0,k->3,l->-4}}
14: {257,{a->1,b->4,c->6,d->0,e->8,f->-3,g->3,h->0,i->2,j->2,k->0,l->4}}
15: {242,{a->1,b->4,c->1,d->3,e->4,f->0,g->1,h->2,i->1,j->2,k->0,l->2}}
16: {252,{a->0,b->5,c->-3,d->4,e->2,f->7,g->0,h->3,i->-1,j->2,k->0,l->0}}
17: {245,{a->4,b->0,c->4,d->5,e->1,f->0,g->0,h->3,i->-4,j->0,k->2,l->0}}
18: {253,{a->4,b->0,c->0,d->1,e->5,f->-2,g->2,h->0,i->8,j->0,k->2,l->-2}}
19: {264,{a->0,b->4,c->0,d->5,e->0,f->6,g->2,h->0,i->6,j->0,k->2,l->-4}}
20: {262,{a->0,b->4,c->-4,d->5,e->0,f->1,g->2,h->0,i->4,j->0,k->2,l->-6}}

Note: This solver assumes that the linear code after the loop is all on the top line, and the above code is that solution folded up. There might be a shorter overall solution by making the solver aware of the folding, because now I get 3 more +s in the first part for free, and the next 4 instructions would cost only 1 byte instead of 2.

2@justhalf You should see my Pada answer. :P – Martin Ender – 2015-08-29T14:49:35.760

Martin I love this answer. Would you consider making a post about this at our official forum ? We use the same as stackexchange editor. Our editorial would like to add it to Staff Picks.

– Vitaliy Kaurov – 2017-09-20T15:24:49.210

65

# Dark, 106 bytes

+h hell
h$twist sign s s$scrawl " Hello, World!
s$read h$twist stalker o
o$stalk o$personal
o$echo h$empty

I'll just let some quotes from the language specification speak for the brilliance of this esolang:

Dark is a language based on manipulating entire worlds and dimensions to achieve goals and to build the best torturous reality possible.

Whenever a syntax error occurs, the program's sanity decreases by 1. [...] If the program's sanity reaches zero, the interpreter goes insane.

Corruption flips a single bit in the variable when it occurs.

When the master dies, all servant variables attached to that master also die. This is useful for grouping and mass killing variables.

Forces a variable to kill itself, freeing it (remember though that it will leave decay).

Sets a variable to a random value. Uses the Global Chaos Generator.

If a stalker is not initialized, any attempts to perform IO will result in depressing error messages to be written to the console.

39This language is so metal. – Alex A. – 2015-09-02T19:53:21.790

9If we had to list programming languages in order of evilness, Dark would top evil. – LukStorms – 2015-10-02T11:21:00.467

41there is hell in hello – Khaled.K – 2015-12-13T08:13:35.547

super evil, you can even raise an army of walking gotos – bobrobbob – 2018-06-11T12:48:09.507

63

# Chef, 465 bytes

H.

Ingredients.
72 l h
101 l e
108 l l
111 l o
44 l C
32 l S
87 l w
114 l r
100 l d
33 l X

Method.
Put X into mixing bowl.Put d into mixing bowl.Put l into mixing bowl.Put r into mixing bowl.Put o into mixing bowl.Put w into mixing bowl.Put S into mixing bowl.Put C into mixing bowl.Put o into mixing bowl.Put l into mixing bowl.Put l into mixing bowl.Put e into mixing bowl.Put h into mixing bowl.Pour contents of the mixing bowl into the baking dish.

Serves 1.

Tested with the Ruby interpreter. Makes alphabet soup.

I tried to be as compliant to the original spec as I could, so even though the interpreter I used lets you drop the thes in the Pour contents instruction, I haven't done so.

The mixing bowl is pretty expensive, so there might be a better approach. I tried using base conversion to encode the message, but unfortunately the spec doesn't clarify whether Divide uses integer or floating point division, and the interpreter I have uses the latter. There's also no modulo operator, which doesn't help either.

21If anyone could golf in Chef it's Sp. – Alex A. – 2015-08-28T16:47:14.197

12Now try golfing recipes in real life. :D – mbomb007 – 2016-01-15T19:24:26.130

2Lol, this is not only not good to eat, but also uses non-standard measuring units. XD – thepiercingarrow – 2016-06-29T20:28:42.487

62

# Homespring, 58 bytes

Universe net hatchery Hello,. World!  powers a b snowmelt

The trailing space is significant.

Let me tell you a story. There was once a power plant which powered a nearby salmon hatchery. The salmon hatchery hatched a young homeless salmon which embarked on a journey upriver to find a spring. It did find such a spring, with the poetic name "Hello, World!", where it matured and spawned a new young salmon. Both fish now swam downstream, in search of the wide ocean. But just short of the mouth of the river, there was a net in the river - the mature fish was caught and only the young one managed to slip through and reached the ocean and the rest of the universe. In the meantime, the hatchery had hatched more salmon which had travelled upstream as well and spawned and so on and so on.

However, vast amounts of melting snow had been travelling down a different arm of the river. And just after our first young salmon from the springs of "Hello, World!" has reached the ocean, the snowmelt hit the universe and... uh... destroyed it. And they lived happily ever after... or I guess they didn't.

Those were actually the semantics of the above program. Homespring is weird.

17This is...weird... – kirbyfan64sos – 2015-09-03T22:35:19.593

12I haz found a new favorite salmon-powered universe destroyer...uh...I mean "Hello, World!" program. +1 – ETHproductions – 2015-11-21T18:58:39.227

8Every time I come back to this, I have a good laugh. Thanks for creating possibly the most entertaining Hello, World! program of all time. – ETHproductions – 2016-03-14T16:18:14.583

3This is my new favorite language. – univalence – 2017-07-08T12:23:16.940

https://tio.run/#homespring – Dennis – 2018-04-28T04:47:01.033

57

# HTML, 13 bytes

Hello, World!

The text is automatically inserted into the <body>, and is displayed.

175Wow. That's some really hardcore coding skills – BlueWizard – 2015-08-28T22:06:00.933

3@JonasDralle at least it does what you'd expect! – jrich – 2015-08-28T22:08:50.307

49HTML is not a programming language, but a markup language (that's why it ends with ML). – CodeManX – 2015-09-03T00:17:35.590

37But HTML isn't printed in STDOUT. – Harshil Sharma – 2015-09-04T05:44:51.940

28-1 HTML Doesn't meet the requirements for a valid language – Downgoat – 2015-09-08T00:25:31.310

5HTML doesn't print to STDOUT – Oliver Ni – 2015-10-16T17:10:50.357

4HTML doesn't stop people not refraining from repeating each other. It's just a markup language! – wizzwizz4 – 2016-01-09T09:44:58.193

11@Doᴡɴɢᴏᴀᴛ Since this is a constant output challenge, languages that don't meet our usual requirements for a programming language are allowed. – a spaghetto – 2016-01-10T04:39:45.740

6HTPL, anyone??? – metalim – 2016-04-06T22:13:58.270

142-1 not enough jQuery – Valentin Lorentz – 2016-06-01T19:40:12.367

23This is a polyglot, also works in plaintext! – fede s. – 2016-08-09T03:12:09.253

1@CoDEmanX: By that logic, is ML a markup language? – Mark – 2017-07-14T13:13:36.603

@Mark Hmm, rather "ML in HTML stands for markup language"? Although a markup language = a markup language (as in identity definition?) – CodeManX – 2017-07-26T21:33:06.120

@CoDEmanX: I meant the language called ML (by Robin Milner and others), but it wasn't really serious :-) – Mark – 2017-07-27T06:46:53.517

ML can also mean "meta language", which is the same as programming language IIRC – RedClover – 2018-04-12T14:56:03.543

1

Also works in Text

– Hello Goodbye – 2019-11-12T20:23:36.440

Just make it HTML+CSS, and you're golden. https://stackoverflow.com/a/5239256/4294399

– Calculuswhiz – 2020-01-11T14:07:37.367

55

# Piet, 84 codels

28x3, here shown with codel width 10.

Created with PietDev, tested with npiet. The layout of the program is the following:

Yellow fill indicates codels where the path overlaps, orange fill indicates codels which must be the same color, for purposes of control flow.

To aid in the creation of this, I wrote a rudimentary interpreter for a stack-based language with piet-like commands, which I have dubbed "pasm" (source). The output from this interpreter (with this input) is the following:

1 nop     blu1 []
4 push 3  blu2 [3]
5 dup     grn2 [3, 3]
7 dup     ylw2 [6, 6]
8 mul     grn1 [36]
9 dup     red1 [36, 36]
10 dup     blu1 [36, 36, 36]
H  12 putc    blu0 [36]
15 push 3  blu1 [36, 3]
16 sub     mgn2 [33]
17 dup     cyn2 [33, 33]
20 push 3  cyn0 [33, 33, 3]
21 mul     blu2 [33, 99]
22 push 1  blu0 [33, 99, 1]
24 dup     cyn0 [33, 100, 100]
25 push 1  cyn1 [33, 100, 100, 1]
26 add     blu1 [33, 100, 101]
e  27 putc    cyn0 [33, 100]
28 dup     ylw0 [33, 100, 100]
32 push 4  ylw1 [33, 100, 100, 4]
33 dup     mgn1 [33, 100, 100, 4, 4]
34 add     red1 [33, 100, 100, 8]
35 add     ylw1 [33, 100, 108]
36 dup     mgn1 [33, 100, 108, 108]
l  37 putc    blu0 [33, 100, 108]
38 dup     grn0 [33, 100, 108, 108]
l  39 putc    ylw2 [33, 100, 108]
40 dup     mgn2 [33, 100, 108, 108]
43 push 3  mgn0 [33, 100, 108, 108, 3]
44 add     red0 [33, 100, 108, 111]
45 dup     blu0 [33, 100, 108, 111, 111]
o  46 putc    cyn2 [33, 100, 108, 111]
47 dup     ylw2 [33, 100, 108, 111, 111]
48 dup     mgn2 [33, 100, 108, 111, 111, 111]
53 push 5  mgn0 [33, 100, 108, 111, 111, 111, 5]
54 div     ylw0 [33, 100, 108, 111, 111, 22]
55 dup     mgn0 [33, 100, 108, 111, 111, 22, 22]
56 add     red0 [33, 100, 108, 111, 111, 44]
57 dup     blu0 [33, 100, 108, 111, 111, 44, 44]
,  58 putc    cyn2 [33, 100, 108, 111, 111, 44]
59 dup     ylw2 [33, 100, 108, 111, 111, 44, 44]
60 add     grn2 [33, 100, 108, 111, 111, 88]
64 push 4  grn0 [33, 100, 108, 111, 111, 88, 4]
65 dup     red0 [33, 100, 108, 111, 111, 88, 4, 4]
66 mul     ylw2 [33, 100, 108, 111, 111, 88, 16]
67 dup     mgn2 [33, 100, 108, 111, 111, 88, 16, 16]
68 add     red2 [33, 100, 108, 111, 111, 88, 32]
69 putc    mgn1 [33, 100, 108, 111, 111, 88]
70 push 1  mgn2 [33, 100, 108, 111, 111, 88, 1]
71 sub     red0 [33, 100, 108, 111, 111, 87]
W  72 putc    mgn2 [33, 100, 108, 111, 111]
o  73 putc    blu1 [33, 100, 108, 111]
76 push 3  blu2 [33, 100, 108, 111, 3]
77 add     mgn2 [33, 100, 108, 114]
r  78 putc    blu1 [33, 100, 108]
l  79 putc    cyn0 [33, 100]
d  80 putc    grn2 [33]
!  81 putc    ylw1 []

No pointer, switch, or roll commands are used. No codels are wasted either; in fact two are reused.

Congrats, you got my bounty :) – LegionMammal978 – 2015-12-25T12:19:01.860

@LegionMammal978 Thanks, it was fun to work on. And merry christmas :) – primo – 2015-12-25T12:25:01.130

11This is what hollywood should show on "hacker" screens. – Hubert Grzeskowiak – 2017-05-29T16:09:08.143

54

# Whitespace, 192150 146 bytes

Whitespace only needs spaces, tabs and linefeeds while other characters are ignored.
Which can be troublesome to display on here.
So in the code below the spaces & tabs were replaced.
And a ';' was put in front of the linefeeds for clarity.
To run the code, first replace . and > by spaces and tabs.

...;
..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
.;
.;
>.>;
...>>.>.>>;
>...>;
..;
.;
;
;
..>;
;
;
;

### Hexdump of code

00000000: 2020 200a 2020 0909 2020 0920 0920 0a20
00000010: 2009 0909 090a 2020 2009 0a20 2020 0909
00000020: 090a 2020 2009 2020 0a20 2009 0920 0920
00000030: 200a 2020 0909 2020 0920 0909 0a20 2009
00000040: 0909 0909 0909 0a20 2020 0920 200a 2020
00000050: 2009 0a20 0a20 2020 0909 0920 0a20 2009
00000060: 0920 2020 0909 0a0a 2020 0a20 0a20 0a09
00000070: 2009 0a20 2020 0909 2009 2009 090a 0920
00000080: 2020 090a 2020 0a20 0a0a 0a20 2009 0a0a
00000090: 0a0a

### Whitespace assembly code:

push 0      ;null
push -74    ;! chr(33)
push -7     ;d chr(100)
push 1      ;l chr(108)
push 7      ;r chr(114)
push 4      ;o chr(111)
push -20    ;W chr(87)
push -75    ;  chr(32)
push -63    ;, chr(44)
push 4      ;o
push 1      ;l
dup         ;l
push -6     ;e chr(101)
push -35    ;H chr(72)
p:
dup jumpz e
jump p
e:
exit

I had to write a program just to calculate that adding 107 gives the optimal golf for the sentence. Since the bytesize that an integer takes in the code changes. : 4+int(abs(log2($n))) The code will still run without the "e:" label & exit part on whitespace.kauaveel.ee. But that could make the whitespace code invalid on other whitespace compilers. So those bytes weren't golfed out from the solution. It Should Be Noted That As Kevin Cruijssen pointed out in the comments, by allowing an "exit by error" as per meta, the Whitespace can be golfcoded more to 126 characters. ..>>..>.>.; ..>>>>; ...>; ...>>>; ...>..; ..>>.>..; ..>>..>.>>; ..>>>>>>>; ...>..; ...>; .; ...>>>.; ..>>...>>; ; ..; ...>>.>.>>; >...>; ..; .; ; Assembly: push -74 push -7 push 1 push 7 push 4 push -20 push -75 push -63 push 4 push 1 dup push -6 push -35 label_0: push 107 add printc jmp label_0 1 I know it's been a while, and I see you're mentioning it does run without the exit-label on most compilers, but you can lower it to 129 bytes by exiting with an error using an SSN (error value) instead of SSSN (push 0), which is allowed according to the meta. Try it online (with added highlighting and explanation), or try it online raw. – Kevin Cruijssen – 2018-03-16T15:44:31.127 @KevinCruijssen I finally checked your version. It's basically the old version with the assembly dup jumpz e and the e: exit removed. But at least on whitespace.kauaveel.ee it keeps on looping till the browser complains. I'd rather not change my version to that, despite the lower golf and the meta allowing "exit by error". But you're free to submit your version as a new answer. – LukStorms – 2018-03-27T19:49:01.030 Nah, I won't post a separated answer. It's basically the same as yours, just a tiny bit shorter due to exit by error. I also just realized I can lower it to 126 instead of 129 by removing the SSN at the start, in which case it errors with Can't do Infix Plus when it only has a single item on the stack (the 107). (Try it online.) I'll just leave my comment here when anyone has the same suggestion. And I've already +1-ed your answer about a year ago I think. ;) – Kevin Cruijssen – 2018-03-27T20:08:55.610 1@KevinCruijssen In that case, your solution has now been noted in the answer. Whitespace is one of the most unlikely languages to golf in. But for the sake of saving bytes your findings are worth mentioning. – LukStorms – 2018-03-27T20:35:42.933 53 # Java, 79 class H{public static void main(String[]a){System.out.print("Hello, World!");}} Earlier versions of Java may allow you to use a static block (51 bytes), but currently I don't know of a way to bypass the main method. 1The static block trick resulted in something being written to stderr, which is not acceptable here. – aditsu quit because SE is EVIL – 2015-08-28T16:17:30.170 Ah, right. I was thinking there was something like that, so didn't post the actual code. Didn't have version <7 at hand to test, though. – Geobits – 2015-08-28T16:19:50.503 8Use enum instead of class. – Thomas Eding – 2015-08-29T07:41:20.930 6 @ThomasEding What compiler does that actually work on? I've tried this tip on several, and have never been able to save bytes with it. – Geobits – 2015-08-29T15:57:12.530 I know I've recently seen an example of using an enum to bypass the main call somewhere around here. Only worked for Java 1.5 though. – Luminous – 2015-09-01T13:29:15.987 5@Luminous Ah, it might have worked for 1.5. I'm not going to install it to find out, though, but stick to something released in the last 10 years. If I never see Java 5 again it'll be a nice life :) – Geobits – 2015-09-01T13:34:12.813 1Processing (also java): print("Hello, World!"); – TheDoctor – 2015-09-01T23:48:35.813 2@TheDoctor From what I've seen, Processing is usually seen as a separate language here. You should post it as an answer, or at least ask for clarification from the OP. – Geobits – 2015-09-02T00:41:11.100 @Geobits That's why I didn't post it as an answer. – TheDoctor – 2015-09-02T01:50:33.773 2@ThomasEding Declaring it as an enum would require a semicolon at the start of the class body, since it's required to start with type declarations. It would still come out to 79 bytes. – caseif – 2015-09-04T17:04:10.453 6 User OptiFine suggested saving 3 bytes by using an interface and ditching the public specifier. I've rejected the edit following policy but since they can't comment, I thought I'd let you know so you can use it if you like. – Martin Ender – 2016-04-07T09:09:45.067 1U may be able to use interface than a class in Java 8 – Sudara – 2016-10-13T05:35:26.957 Beaten by TheNumberOne's answer with -3 bytes. – Stevoisiak – 2017-09-14T16:07:31.360 @StevenVascellaro ... which in turn is beaten by my answer with -14 bytes. – Olivier Grégoire – 2017-09-20T07:48:54.613 52 # CSS, 30 bytes :after{content:"Hello, World!" Cascading Style Sheets (CSS) isn't a typical programming language, but it can do fixed output fairly well. This is done by creating a pseudo-element after every element with the content Hello, World!. So only one element (<html>) is selected, this assumes that we're using the most basic HTML document, i.e. <html><style>:after{content:"Hello, World!"</style></html> This works in most major browsers, with the notable exception of Firefox, which applies the selector to the <html> and <body> elements. This is also why Stack snippets don't work, because there is always a body element that gets styled as well. Below is a slightly modified version to test. * :after{content:"Hello, World!" 3You can also use * * to select body. – jimmy23013 – 2015-08-31T07:50:15.643 19@jimmy23013 That sounds gloriously inefficient. Thanks – NinjaBearMonkey – 2015-08-31T18:09:31.893 1For whatever reasons * :after also seemed to work. – jimmy23013 – 2015-09-01T02:20:28.647 @jimmy23013 Um... of course? * :after** means the **:after** content insertion point of an element that has any element (***) in its ancestor tree. That's why you can do stuff like div a: an a element that has a div as one of its ancestors. – Toothbrush – 2015-09-04T17:55:36.930 1@toothbrush I know it is by design, but that just doesn't mean I like it. Intuitively, body::after is in body just like div a in div. – jimmy23013 – 2015-09-04T18:08:01.073 @jimmy23013 Yeah, I agree. It isn't intuitive that you apply ::after to the element you want to insert the content into. – Toothbrush – 2015-09-04T18:19:52.473 12I'm asking my self which of the letters in CSS is the abrreviation for "language". – Zaibis – 2015-09-07T14:27:35.027 14@zaibis the same letter for PHP probably :) – Fabrizio Calderan loves trees – 2017-02-02T22:55:46.657 – arodebaugh – 2017-05-09T16:11:56.623 46 # x86_64 machine code for Linux, 32 bytes When Linux starts a new process, all the registers (except RSP) are zero, so we can get RAX=1 by only modifying the low byte. The x86-64 System V ABI doesn't guarantee this, but it's what Linux actually does. This code only works as _start in a static executable. 0000000000000000 <_start>: 0: e8 0d 00 00 00 call 12 <hello> 5: 48 65 6c 6c 6f a: 2c 20 57 6f 72 f: 6c 64 21 5e 40 0000000000000012 <hello>: 12: 5e pop rsi 13: 40 b7 01 mov dil,0x1 16: b2 0d mov dl,0xd 18: b0 01 mov al,0x1 1a: 0f 05 syscall 1c: b0 3c mov al,0x3c 1e: 0f 05 syscall The call instruction pushes the next address, which contains the hello world string, onto the stack. We pop the address of the string into rsi. Then the other arguments are set up for a syscall to sys_write, which prints the string. The program terminates with a syscall to sys_exit. sys_write returns the number of bytes written, so the upper bytes of RAX are zero after the first syscall (unless it returned an error), so mov al, 60 gives us RAX = __NR_exit in only 2 bytes. You can make this program segfault by closing its stdout (./a.out >&-), so sys_write() will return -EBADF, the second syscall will return -ENOSYS, and then execution will fall off the end. But we don't need to handle write() errors gracefully. 1Specifically this only works on Linux, where __NR_write is 1. This is not standard across different x86-64 Unix systems. You're also depending on the Linux behaviour of zeroing all registers except RSP before entry into a fresh process (so this only works if you build it as a static executable, otherwise the dynamic linker will leave garbage in the upper bytes of rax and you'll get -ENOSYS). The x86-64 System V ABI says registers can hold arbitrary garbage values on entry to _start, the Linux kernel itself chooses zero them to avoid info leaks. – Peter Cordes – 2018-04-13T03:40:58.813 You can save a byte with mov al, 1 / mov edi, eax (2 bytes), instead of needing a REX prefix for DIL, because __NR_write == STDOUT_FILENO = 1 – Peter Cordes – 2018-04-13T03:43:16.287 1 This only works in a Linux static executable, so the address of your string is guaranteed to be in the low 2G of virtual address space (the default memory model for non-PIE executables puts all symbols where they can be used as zero or sign-extended 32-bit immediates). Thus you can use 5-byte mov esi, msg (NASM) aka mov esi, OFFSET msg (GAS .intel_syntax). Put your string after the last syscall. call/pop is 1 byte shorter than 64-bit RIP-relative LEA, but mov is best. – Peter Cordes – 2018-04-13T03:48:02.907 – Peter Cordes – 2018-04-13T04:11:38.633 44 # Hexagony, 37 32 bytes Notice: I'll be giving a bounty of 500 rep to the first person who finds a valid solution in a hexagon of side-length 3 or a provably optimal solution of side-length 4. If you can't find such a solution but manage to beat my score in a side-length 4 hexagon (by getting more no-ops at the end of the program, which can be omitted from the source code), I'm willing to give out a smaller bounty for that as well. H;e;P1;@/;W;o;/l;;o;Q/r;l;d;2;P0 Try it online! I proudly present my second 2D programming language, and (to my knowledge) the first ever 2D language on a hexagonal grid. The source code doesn't look very 2D, does it? Well, whitespace is optional in Hexagony. First, the source code is padded to the next centred hexagonal number with no-ops (.). The next such number is 37, so we insert five no-ops at the end. Then the source code is rearranged into regular hexagon: H ; e ; P 1 ; @ / ; W ; o ; / l ; ; o ; Q / r ; l ; d ; 2 ; P 0 . . . . . This is also runnable. Try it online! Hexagony has a bunch of pretty funky features, including 6 different instruction pointers and a memory layout which is the line graph of a hexagonal grid, but this code uses only one IP and one memory edge, so let's not worry about that for now. Here is an overview over the relevant commands: • Letters just set the current memory edge to their ASCII value • ; prints the current value, modulo 256, as a byte to STDOUT. • / is a mirror which behaves as you'd expect (causing the IP to take a 120 degree turn). • Digits work as they do in Labyrinth: they multiply the current cell by 10 and then add themselves. • @ terminates the program. Now the final catch is that the source wraps around all 3 pairs of edges. Furthermore, if the IP leaves the grid through one of the six corners, there are two possible rows to jump to. Which one is chosen depends on whether the current value is positive or non-positive. The following annotated version shows where the IP re-enters each time it leaves the grid: H ; e ; -> 1 5 -> P 1 ; @ / -> 4 3 -> ; W ; o ; / -> 2 1 -> l ; ; o ; Q / 4 -> r ; l ; d ; -> 5 2 -> 2 ; P 0 . -> 3 . . . . So if we remove all the direction changes, this program boils down to the following linear code: H;e;l;;o;Q2;P0;W;o;r;l;d;P1;@ What's with Q2, P0 and P1? Letters are printed easily because we can just set the edge to the corresponding value. For the comma, the space and the exclamation mark, that doesn't work. We also can't just set their value with 44, 32, 33, respectively, because the memory edge is non-zero to begin with, and due to the semantics of individual digits that would wreak all sorts of havoc. If we wanted to do that, we'd have to reset the edge value to zero with something like *, +, -, & or ^ first. However, since the value is taken modulo 256 before being printed we don't have to set the values exactly to 44, 32, or 33. For instance, Q2 will set the edge value to 81*10 + 2 = 812, which is 44 when taken modulo 256. This way we can save a byte on each of those three characters. (Unfortunately, it's never possible to get there with a single digit from the value the cell already has. Amusingly, where it does work is the o in World, because that can also be obtained from W9.) You can use this CJam script to find all letter-digit combinations that result in a given character. I'm not sure whether this is optimal. I doubt it's possible to do it in a hexagon of side-length 3 (where you'd only have 19 characters available), but it might be possible to solve it in a hexagon with side-length 4 with less than 32 commands, such that there are more no-ops at the end of the grid. 1Dammit, you beat me to it. I myself am working on a hexagonal language kind of similar to Cardinal. – M L – 2015-09-14T16:49:36.200 How did you find this solution? By hand or brute-force? Anyway, +1 :) – Adnan – 2016-01-25T15:19:19.430 @Adnan By hand. It's the simplest linear layout you could possibly have, I think. (I did write a CJam script to find combinations of letter + digit that give ,, space and ! if that's what you're asking. There are two solutions for each of them.) – Martin Ender – 2016-01-25T15:20:01.717 1The Q2, P0 and P1 is very clever. I didn't know the modulo 256 part. – Adnan – 2016-01-25T15:27:57.387 1@Adnan The person who suggested the mod-256 part on GitHub actually did so along with the example that linefeeds could then be printed as M8; (or g4;), which I've used a couple of times since then. It just never occurred to me until now to revisit this answer after I made that change. – Martin Ender – 2016-01-25T15:29:21.220 And it just shortend this submission by 5 bytes easily. I have also spent some time to actually golf this, but I didn't succeed and never actually came up with this. I will think of this in the future though :). – Adnan – 2016-01-25T15:52:46.357 3 Note: This was reduced to 31 a while ago. H;e;P;2Q/d;l;r/l;$@;o];o;W;03&;

– Mitch Schwartz – 2016-10-24T10:00:19.053

41

# C, 30 Bytes

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

Fairly vanilla, but I can't think of a commonly compilable way to do it any shorter (unless maybe some kind of raw asm trick might work?). Still, beats most esolangs!

3It's not worth a separate answer, but the fully ISO compliant C89 and C99 answers are 39 main(){puts("Hello, World!");return 0;} and 53 #include <stdio.h> int main(){puts("Hello, World!");} bytes respectively. Slightly more if you think main(void) is required. – Random832 – 2015-08-28T16:29:51.690

26@Random832: for the former, main(){return!puts("Hello, World!");} is two bytes shorter. – Lynn – 2015-08-28T19:56:25.837

23The program h is 29 bytes shorter. Note: you'll have to compile it with -Dh='main(){puts("Hello, World!");}' I'm half trolling, half amusing myself with compiler abuse. – matega – 2015-08-29T19:54:55.997

26@matega That is clearly cheating. For it not to be cheating you'd have to make the file contain only __FILE__ (8 bytes) and name the file main(){puts("Hello, World!");}. Then it is totally not cheating ;) – C0deH4cker – 2015-09-03T08:12:20.767

Actually, by 2017 rules those would be 34 and 38 bytes respectively. – CalculatorFeline – 2017-06-20T21:23:49.683

1main(){puts(__FILE__"!");} with a file name of "Hello, World" is 26 bytes. – mreff555 – 2020-06-21T15:31:07.160

41

## Malbolge, 112 bytes

('&%:9]!~}|z2Vxwv-,POqponl$Hjihf|B@@>,=<M:9&7Y#VV2TSn.Oe*c;(I&%$#"mCBA?zxxv*Pb8qo42mZF.{Iy*@dD'<;_?!\}}|z2VxSSQ

I'm going to see if there's a shorter one. Got a better computer since last time, so I can generate quite a bit faster.

For show, here's "Hello World!" without the comma.

(=<#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?=*z]Kw%oG4UUS0/@-ejc(:'8dc

How about this one? ('<;_#"~6Z|{y1UTvt,PrpMo,llj"Fgge{A??P=^t:8&7YtFVqjSQ@PNM)u(I8%$#"D2AA/[TYXQu88MLp3n1Gk.D-ge (92 bytes) – dingledooper – 2019-10-15T00:50:16.967 271 bytes – ceilingcat – 2020-02-19T23:29:49.877 38 # C--, 155 bytes target byteorder little;import puts;export main;section"data"{s:bits8[]"Hello, World!\0";}foreign"C"main(){foreign"C"puts("address"s);foreign"C"return(0);} Unfortunately, the only known C-- compiler, Quick C-- is no longer maintained. It's a pain in a neck to build, but it is possible... 10Really fascinating language - I'd never heard of it before, and it's certainly an ambitious project that they (were/are) doing. But in terms of code golf, I don't think it'll be a contender. I mean ... dang, this thing loses to Java ... – AdmBorkBork – 2015-08-28T20:20:50.857 12@TimmyD It's really an assembler. There's a reason it loses to Java... :) – kirbyfan64sos – 2015-08-28T20:21:23.790 3I have good news for you. While the C-- project itself seems to be quite dead, one variant is quite alive. The Glasgow Haskell Compiler (GHC) uses C-- as its final stage before assembly or LLVM, and that version is still actively maintained. It shouldn't be any trouble whatever to get it installed (along with the rest of GHC). – dfeuer – 2019-08-12T17:39:43.710 @dfeuer Indeed I tried using their Cmm backend directly before, but I had some weird issues and never really looked into it much further ¯\_(ツ)_/¯ – kirbyfan64sos – 2019-08-13T00:27:51.330 You can probably get some help on the Haskell mailing lists. Try glasgow-haskell-users@haskell.org, or perhaps haskell-cafe@haskell.org. – dfeuer – 2019-08-13T01:12:13.947 37 # Fourier, 15 bytes BIG CHANGES to Fourier! Hello, World! Try it on FourIDE! Yes, the days of typing out the ASCII code of each character are gone forever: Fourier now kind of supports strings. When you enclose a string in backticks, that string will be outputted. Note that you can't do anything other than output that string: you cannot store it in a variable, it is not stored in the accumulator and there are no string manipulation tools. Here, you can find the train wreck that was old Fourier. ;) 72a101a+7aa+3a44a32a87a111a+3a-6a-8a33a Try it online! Now, some of you will probably have met Fourier before and may be fairly familiar with the language. The whole language is based upon an accumulator: a global variable which pretty much all operators use. The most important part of the code is the a operator. This takes the numerical value of the accumulator and converts it to a character using the Python code chr(accumulator). This is then printed to STDOUT. Unfortunately, I haven't had the chance to use Fourier yet (nudge nudge, wink wink), mainly because of its lack of strings and string operators. Even so, it's still usuable for many other challenges (see the examples section of its EsoLangs page). Note that this is shorter than my entry into the Esolangs list because I didn't actually think that I could golf it any more. And then, when writing the Fourier string golfing challenge, I realised I could go quite a bit shorter. ## Note If you were wondering about variable syntax, Geobits wrote a program which uses variables and is the same length: 72a101a+7aa+3~za44a32a87aza+3a-6a-8a/3a Try it online! What's a usuable? Is it like a usable? – CalculatorFeline – 2016-03-25T23:59:11.973 36 # Unreadable, 843755732666645629 577 bytes '"'""'""'""'"'"'""""""'""'"""'""'""'""'""'""'""'""'"'""'""""""'""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'""""""""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"""'"'"""""""'""""""""'"""'"'"""""""'"""'"'"""""""'""'""'"""'"'""'""'""'"'""'""'""'"""""""'""'"""'"'"""""""'""'"""'"'"""""""'""'""'""'"""'"'""'"""""""'""" Unreadable programs are supposed to be displayed with a variable-width font, so they honor the language's name. I'm slightly disappointed that my more sophisticated approaches turned out to be a lot longer. Loops are insanely expensive in Unreadable... Try it online! ### How it works Unreadable has only ten functions; six of these are used in this code: '" p Print. '"" + Increment. '""" 1 Return 1. '"""""" : Set. '""""""" = Get. '"""""""" - Decrement. After using my single-character notation and adding some whitespace and comments, the above code looks like the following. Multi-line statements are executed from bottom to top. p+++ Print 3 + variable 2 (o). pp Print variable 2 two times (l). :+1+++++++ Save 8 + variable 3 in variable 2. p+ Print 1 + variable 3 (e). :++1+++++++++++++ Save 13 + variable 4 in variable 3. :+++1+++++++++++++++ Save 43 + variable 0 in variable 4. p++++++++++++++++++++++++++++ Print 28 + variable 0 (H). :-1++++++++++++ Save 44 in variable 0. :1+++++++++++++++++++++++++++++++1 Save 32 in variable 1. p=-1 Print variable 0 (,). p=1 Print variable 1 ( ). p=+++1 Print variable 4 (W). p+++ Print 6 + variable 2 (r). p+++=+1 Print 3 + variable 2 (o). p=+1 Print variable 2 (l). p=++1 Print variable 3 (d). p+=1 Print 1 + variable 1 (!). I've generated the actual source code by running the uncommented version of the above pseudocode through this CJam program. 4What are you talking about? Its pretty readable! – Optimizer – 2015-09-03T19:03:01.273 21@Optimizer Fixed. – Dennis – 2015-09-03T19:06:45.300 5Still readable! (of course I am telling the truth. Why won't you believe me?) – Optimizer – 2015-09-03T19:10:43.030 7Feels like this language would benefit from a better huffman coding - both in terms of size, and unreadability. – primo – 2015-09-29T09:05:47.573 35 # JSFuck, 62936289 6277 bytes This may get a mention as one of the longest "shortest Hello, World! programs" (actually I do not know if this is optimal, but it's the shortest I managed to get). Warning: only works in Firefox and Safari [][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]](([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))() There is also a slightly longer version (+4 bytes) that also works in Chrome and Microsoft Edge: [][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]]((![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))() For those unfamiliar with JSFuck, it's about writing JavaScript as if there were only six characters, and it can get pretty crazy at times. This table shows how the characters used in the Hello, World! program are encoded in JSFuck. The plain text code is just alert("Hello, World!"). +----------+--------------------------------------+---------------------------+ |JavaScript| write as | JSFuck | +----------+--------------------------------------+---------------------------+ | a | (false+[])[1] | (![]+[])[+!![]] | | l | (false+[])[2] | (![]+[])[!![]+!![]] | | e | (true+[])[3] | (!![]+[])[!![]+!![]+!![]] | | r | (true+[])[1] | (!![]+[])[+!![]] | | t | (true+[])[0] | (!![]+[])[+[]] | | ( | ([]+[]["fill"])[13] | 114 bytes | | " | ([]+[])["fontcolor"]()[12] | 539 bytes | | H | btoa(true)[1] | 1187 bytes | | o | (true+[]["fill"])[10] | 105 bytes | | space | ([]["fill"]+[])[20] | 107 bytes | | W | (NaN+self())[11] | 968 bytes | | d | (undefined+[])[2] | ([][[]]+[])[!![]+!![]] | | ! | atob((Infinity+[])[0]+false)[0] | 1255 bytes | | ) | (0+[false]+[]["fill"])[20] | 114 bytes | +----------+--------------------------------------+---------------------------+ Here the strings "fill", "fontcolor", etc. must be written as "f"+"i"+"l"+"l", "f"+"o"+"n"+"t"+"c"+"o"+"l"+"o"+"r" to be encoded. The global identifiers self, atob and btoa get written like Function("return self")(). Function itself should be []["fill"]["constructor"]. The comma "," is tricky, I'm not 100% sure how it works but it uses the []["concat"] function to create an array. I'll post an update when I have time to do more tests. I encoded this using JScrewIt - credits to GOTO 0 for creating such a sophisticated tool: • Open Firefox (You can choose any other browser(s), but Firefox only code is the shortest.) • Navigate to JScrewIt: http://jscrew.it • Input: alert("Hello, World!") • Executable code: checked • Compatibility: Only this browser This differs from my answer to this question for the presence of the comma after "Hello". Interestingly, the ES6 syntax alertHello, World! takes even more bytes to encode (+1500 or so) because of the higher complexity of encoding two backticks rather than (" and "). Well it works in Chrome on Android – Beta Decay – 2015-08-30T08:25:57.823 Works in Chrome on OS X too – C0deH4cker – 2015-09-03T19:49:47.867 @BetaDecay @C0deH4cker I think that's because of the []["fill"]. Just updated my answer, thanks! – me and my cat – 2015-09-04T07:58:41.587 @Sp3000 Nice!!! Thanks ;) You could report that to JScrewIt as an issue. – me and my cat – 2015-09-06T12:45:58.207 Safari on OS X works too :D – Kametrixom – 2015-09-06T14:29:56.000 2You did a great job here! Be sure to check the last update. – GOTO 0 – 2015-09-07T23:22:37.517 4@GOTO0 Wait... you are the author of JScrewIt, right? – me and my cat – 2015-09-08T05:07:38.457 1How the hell do you call functions with this? – None – 2017-02-06T10:59:35.100 34 # Seed, 415441354117 4078 bytes Explanation, quite long, along with the description of the generation algorithm on my home page (as per request in comments): link Possibly smallest one can create in finite amount of time. Feersum's generator has been outscored by 125 digits. 18 1999111369209307333809858526699771101145468560828234645250681099656696029279480812880779443148152835266354745917034724622145903651417563371730237765283326056988244774110441802133624468817714160177386022056512108401823787027806425684398448067970193332644167536135089961308323052217690818659345826221618714547471817786824952177760705661213021136861627615564344797191592895410701640622192392412826316893318666484043376230339929937013414786228802341109250367744273459627437423609306999946689714086908789713031946200584966850579209651689981508129953665360591585003323062426849065928803791631705897655870676902001410564547259097078231664817435753967511921076054045034302323796976905054512737624542497156263914722954936458789312271946701667519720841308380062811251340113402138536813062807047486584549696366881131076129644333426157514410757991556230404583924322168740934746079177400690540383270574734570453863131129670312070568678426587468145691141064452504683450565188718043501125177371576228281599163415914580472091806809959254536307112226422637068036069837636348250796013947548859219492684001888592443619271863264913733271796439829896342322684180478385639971904415730730155249230972472713598001454701479081682503703435292522488015910406951417625194589254609756805750713606175216991897729604817653297756338264018378339186646236428245791304007449872675676823828828025054891324604572924113135541994460293993994930010757779465315482913805320566037487246911578188713647298779820394853314711728701462997760060773720597833413054385989484972761510228922232188763499675904892361201334056531237561182096332707820332381472154893517831468669407424867949853884550905603295504680929068346527584718316837786318710085149722173684889784734888358566137013072868037395888296895408992035862679921478330680631465096402120764369879221964359613565641652779510635224788673321444028128955312660697375763703507924497355056468329176678508797277505818080245055083627993568557883893217501909841992899324584338401263402065617507377073719573642373296064002058833488593469308722954567388945161866200094063588423591356962865924188962743278147095803148276100759174767606637848987740320689762075562393521992008413240632519860537097220403160035470139899869535541445941688033346042941342229305392639867768112643798588915164061012851035069872578424685533430920913310727097269791325370108354115267003538502506307401037702631576755065238836157990287620373910423088628131973441805618500402407032751005850768445522318425479521483938945040598642922742796671148454685792926662105094734939468210307429214048710552195412807154088634170043145174020299723624868716804740205833308025010299791473201989330179511900752421521748244324520372384555472905196933204791343923384985673930225356512632819977168423365518584516873151142795940198973519372718229122661025988052451376835210066645728260048500257088773609522352231828810506243886764860621803233068079848240668323783996022507908005888468315483796728648978952610219628600082949325089555677853995177602958596492703349550377871982505777660804519503438416790609328789548538308170189581940118961959513239411467871900221985235702327603132341245854941342838886675363828149587290416073764877392438738417021129652498464495269870868163299830870636019233313974206364225614175115905798645888824666280593535350493547833757379214088677125769505793280646751090271497879000895725329057103702349349795211071357094147037863458426851391499872003703049553149335378055054176480977774050198041879243243264959205957441742983643583697591926138999543475339555662645088503078864968452030049140027407987267835123806661736568594687416676322591834962173789578844522343172160526435025531896189408441645468352864002987706103448393710107805248652709736711528349633758515438315407447026188178510124322920110858766628704828773265703683997486487094455425009292414948853993709223752434073750917088611480305840639869649933404702780843770306859066070919534638022435125602050780767420448917941603557783974740312706609928585387278690009349321957381507513875981113699582062422293555869483805964659436085153933836036107786 Try it online! ## Original, 4154 byte version Added per request of @JoKing, because the 1st program doesn't quite run on TIO, albeit being valid. 20 77698190481213510983405846204529755428212736563278528088055816123655499433757607718113585773285686740433752335768949721107461077652705328567448384490378909463204984642622585570301449419608763821501335954761638946551568252142160714228369356054944595121742743720935369219143086698092657062614382519069928478344861416117079283276656675368390764675728501797178208908097054412833019383889935034413095990596139618411133857423995278221670378808372393943846302426674985203826030563290800228881174929701934609803807325868775242909948272754141956168876233403760199007405891058308908050926690654387065882097924294620229833663324754801060691573338185912369627367088050915813931912943122729210762147280440619571047157836177316082899933374851699282897590433145623725705072835054748369992455883804733164985993447304652512229557984322495162682327137071900307763332392727562988633724175094951314863886096190608268953115914497741446723188169519334729165647294618083444761551231012944903572063441813639201051793052623561949314826491616145873848990439549320951496534538450810083853945092224500179417650727351532486362656533602860500906935826231374501097567347929533018944533000919137863885267937690665655625569011036163950983389810112758403211861147501289650757555111271813737813381172074709337306647481507917983021055643749698971365256395367215437223669891280521155247529741719633106765965869860677198632388808752014013939448563313855130972968670015202479226496876067874099463222366536167126653600056389712632892652810365218798697007191747287017174284819764736012653205048166550645507761123345279502597627995423826537299795220169894222867163817508592362092945387317777666016102146798532337718546431888424995701016828542559577710937459975677354300708252448630110787487122698124054544454425586794841157136743408274159313823745226919626156949004386804874236325506583268311452185182143521552429596087556634158778951670223004413763782647825362665491934988477225698133609360969370513836064317152213804169538880632390908441210809806024082600637872813704781431414342781727628446451808751293046212690472851527294326981763969926510021099532791692362104324026231160941956411410511639925420026544463125250979130259151326444714248961523031316570018708849878676230362246913063109584502143502908906243190007062857721367402065760878808920961082444422470813023453274563914735545463757909757689866565064353853099958949763412521666109346825939993377745919874506439752272141853783745051726268592621080457687000431023453539135927140364910898906534604541224314820195082362228787083990333757268808864746297304451768935814651205074884015268982492445996542040655715230139673520569765431617018824427859214902954216246257690105154030408059145566852643855789351907818461502260430297487602982850090037405732117988720732457199005151517240766953718440639691354185802798689950155164379549518496065038927905828230066053603755553745353618846804435103593395141938947781375633374976924393453162350331593801284839409264892975739791751842620029351535320807733966984270102067017902086335370470815153908942490581427972998999752666174807935897314584088695849094389002316139005810918748032068307783088481430339303809949409414892479892121893571274086727250767713365523021125610242269894861374297866741571608166536165735922984579027986499758294460652554897534526492251140681138244025665400003029337114012766773010641359450599171473565675885966777145500248501370644599274741842644014722083732709145488157998306684831419559774212264003518406013032514468522158218837161285401631773099549510145156007147884565387852623860047153609138110997222297132678660783411624002400927435687937355446057878202312894093195453248164648271580944753933355967626542678764854079218206499479071658357103085513937246462858404881973219571392564909528645166637501279457604649906515968389831094896970731573714836150178126997674563415266672131632765794599548356902607125568792417432226125654028873443580337866760487651905138461301986816386866811155111486155341154153322710638921116465132825486519667178335471102213200521032618562169530188826434060179505699797068436325168526618824444305122475837890944742004331675952611756641739756206337285946 Try it online! 2 I don't know Befunge nor Seed, but is there a reason both you and @feersum use the Befunge-98 program "9!dlroW ,olleH"ck,@ (20 bytes)? Won't the Befunge-98 Hello World answer posted here: "ck,@!dlroW ,olleH (which is 18 bytes) result in a shorter Seed program as well? – Kevin Cruijssen – 2019-09-10T08:06:44.903 3Also, the shorter befunge solution is incorrect - it starts with a leading space and no excalamation mark. To fix these issues, the program would be 19 bytes big - that's as much as the no-9 solution I've been working on. – Kamila Szewczyk – 2019-09-10T14:12:46.883 Oh. Is the Python 3 program which converts Seed programs to Befunge from the Seed Esolang page in that case incorrect? Because when I decode feersum's Seed code I get the same Befunge program as when I decode your Seed code. (As I said, i don't know anything about Befunge nor Seed. I simply copy-pasted that Python 3 script and used it for your Seed code when I noticed there is a shorter Befunge answer posted..) – Kevin Cruijssen – 2019-09-10T14:12:59.143 ^ Crap, I haven't updated my answer with the lastest score. Sorry, I will do that in a hour after a new program generates with the best generator. – Kamila Szewczyk – 2019-09-10T14:13:51.610 1The output of the latest revision appears to be incorrect. – Dennis – 2019-09-28T17:38:42.360 @Dennis I'm using the code suggested by Kevin. The deal is probably PyFunge98 is biased and can't run the valid code. – Kamila Szewczyk – 2019-11-01T18:08:38.630 1If you provide an explanation of how you derived your solution, I may bounty depending on how good the explanation is – user41805 – 2019-11-12T18:32:02.750 3 @user41805 I've posed an article lately about this: http://kspalaiologos.now.im/?id=9 – Kamila Szewczyk – 2020-04-08T18:15:52.170 1@Szewczyk I'll award the bounty once you edit the link (or the entire post if it fits) into your answer – user41805 – 2020-07-23T18:45:11.020 @user41805 the article is quite chonky, so I leave the link here – Kamila Szewczyk – 2020-07-23T18:52:14.843 The code you're running produces Hello, World (with a leading space). Only some interpreters will (incorrectly) produce the actual string. Pyfunge has the correct behaviour here, and since Seed uses Pyfunge, you should be accounting for that. – Jo King – 2020-07-23T23:09:49.533 ockquote> Seed uses Pyfunge - no, it doesn't. The specification doesn't mention what kind of interpreter can be used to execute the resulting code. It only happens so that TIO is utilizing PyFunge. – Kamila Szewczyk – 2020-07-24T10:52:51.410 @user41805 would you mind granting the bounty before it expires? – Kamila Szewczyk – 2020-07-27T06:34:18.637 I'm not calling for it to be deleted, but the first version is invalid. The implementation you are using does not print the correct string (and on CGCC implementations are the definitions of languages), and I don't know of any other implementations of Seed that print correctly (though one would be trivial to create). Even if you wanted to go by the pure language specification of Seed and Befunge (though I note the Seed esolang page never mentions which version of Befunge, 93, 98 or the unappreciated 97), your shorter version would still produce the leading space. Forgive my pedantary – Jo King – 2020-08-03T13:41:14.107 31 # Pada, 83 68 bytes ~.O~Ow~q~Owo~O~Oww~Q~qwo~q~O~wQ~q~w~q~q~Q~Ow~Q~Q~wo~q~w.~q~w.~.wO~qw I believe this is optimal for a linear program (i.e. one which doesn't use the control flow operators ? and *). It might be optimal overall, but I don't know how to go about making use of those additional operators in such a small amount of code (or how to explore the possibilities programmatically). The language has recently undergone some changes after I started discussing it with the author by email. However, I have written a reference implementation for the current state of the language spec last week, so the above code is actually runnable. ## Metagolf Originally, I had used the output of my reference implementation to this challenge and created a hand-crafted solution based on that. However, that was just a heuristic approach. So instead I wrote a solver in Mathematica which actually knows about the Pada data structures and operators to find an optimal solution. On average, it grows linearly with the length of the string (although some character combinations are a bit slower than others) and took about 1.5 hours for Hello, World!. So how did I go about writing the solver. First, we notice that we only need to consider 6 operators: ~.oOqQ (plus the necessary w for each of the printed characters). Using the stacks or the bit locks isn't useful in linear code, and I don't believe that ? and * can be used effectively in less than 68 bytes. Pada's state (ignoring the stacks and locks) consists of 7 switches and 8 bits, arranged like this: / / \ / \ / / 0 1 0 0 1 0 0 0 So that's 215 = 32768 possible states. My first preprocessing step was to set up a directed graph of states where each edge corresponds to a single operation. That is, the graph has 32768 vertices, each with out-degree 6 (one outgoing edge for each of the 6 operations under consideration). We can use this graph to find the shortest path between any two states (this graph alone can be quite useful for golfing Pada). Now for each character, we want to reach a state where w prints that character. How many such states are there? w reads the byte from the bit it is dropped on (cyclically). So there are 8 possible rotations of the bits of the character which can all print that character. For each of those rotations, three switches are fixed (in order to make w drop in the correct position). This leaves 4 arbitrary switches. So we've got 8 * 24 = 128 possible states for each w in our code. With those we can solve another graph problem: construct a graph which has a source vertex, then one "layer" for each character, and a sink vertex. The layers consist of the 128 states for each vertex, the source node corresponds to the initial state of the program (all switches to the left and all bits are zero). The sink node corresponds to no state in particular. We've got directed edges from every vertex in one layer to every vertex in the next layer, where the edge weight is the distance between the two states in our earlier graph. The weights of the edges from the last layer to the sink are all 0. That is, we can precompute all those edge weights. This is the most expensive step of the computation and took 1.5 hours for Hello, World!. With this graph set up, we can find the shortest path from the source to the sink quite quickly (it took 0.05s on my machine). For Hello, World! the desired states are: 0, 16960, 22052, 13828, 13828, 30389, 12487, 8307, 27299, 23450, 18922, 22778, 18682, 18459 where the least significant 7 bits correspond to the switches and the most significant 8 bits to Pada's bits. Now we go back to the first graph and find the actual edges (i.e. operations) corresponding to the shortest path between each pair of subsequent states, and end each of them with a w. Voilà, an optimal solution (based on the above assumptions). Here is the full Mathematica if anyone ever wants to metagolf a different string in Pada: string = "Hello, World!"; width = StringLength@string; getState[letter_, state_] := ( {shift, switchState} = IntegerDigits[state - 1, 16, 2]; bits = RotateRight[ IntegerDigits[ToCharacterCode[letter][[1]], 2, 8], shift]; switchState = IntegerDigits[switchState, 2, 4]; switches = {-1, -1, -1, -1, -1, -1, -1}; {top, middle, bottom} = IntegerDigits[shift, 2, 3]; switches[[1]] = top; If[top < 1, switches[[2]] = middle; If[middle < 1, switches[[4]] = bottom, switches[[5]] = bottom ], switches[[3]] = middle; If[middle < 1, switches[[6]] = bottom, switches[[7]] = bottom ] ]; For[i = 1, i <= 7, ++i, If[switches[[i]] < 0, switches[[i]] = First@switchState; switchState = Rest@switchState ] ]; {bits, switches} ) encode[state_] := FromDigits[Join @@ state, 2] decode[id_] := Partition[IntegerDigits[id, 2, 15], 8, 8, 1, {}] getBitFromSwitches[switches_] := ( If[switches[[1]] < 1, If[switches[[2]] < 1, 1 + switches[[4]], 3 + switches[[5]] ], If[switches[[3]] < 1, 5 + switches[[6]], 7 + switches[[7]] ] ] ) toggle[list_, index_] := ReplacePart[list, index -> 1 - list[[index]]] stateEdges = Flatten@Table[ {bits, switches} = decode@id; bit = getBitFromSwitches@switches; { Labeled[id $DirectedEdge] encode@{bits~toggle~bit, switches}, "~"], Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~1}, "."], If[switches[[1]] < 1, { Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~2}, "o"], Labeled[ id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~3}, "q"], If[switches[[2]] < 1, Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~4}, "O"], Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~5}, "O"] ], If[switches[[3]] < 1, Labeled[ id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~3~toggle~7}, "Q"], Labeled[ id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~3~toggle~6}, "Q"] ] }, { Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~3}, "o"], Labeled[ id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~2}, "q"], If[switches[[3]] < 1, Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~6}, "O"], Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~7}, "O"] ], If[switches[[2]] < 1, Labeled[ id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~2~toggle~5}, "Q"], Labeled[ id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~2~toggle~4}, "Q"] ] } ] } , {id, 0, 2^15 - 1}]; stateGraph = Graph[# & @@@ stateEdges, EdgeLabels -> Rule @@@ stateEdges]; uid = 0; layers = Join[{{{uid++, 0}}}, Table[{uid++, encode@getState[#, i]}, {i, 128}] & /@ Characters@string, {{{uid++, -1}}}]; edges = Flatten[Table[ from \[DirectedEdge] to , {from, #}, {to, #2} ] & @@@ Partition[layers, 2, 1], 2]; Timing[weights = ( {from, to} = Last /@ List @@ #; If[to < 0, 0, GraphDistance[stateGraph, from, to] ] ) & /@ edges;] characterGraph = Graph[edges, EdgeWeight -> weights]; Timing[path = Last /@ Most@ FindShortestPath[characterGraph, {0, 0}, layers[[-1]][[1]]]] (PropertyValue[{stateGraph, #}, EdgeLabels] & /@ DirectedEdge @@@ Partition[FindShortestPath[stateGraph, ##], 2, 1] <> "w" & @@@ Partition[path, 2, 1]) <> "" An interesting language to do metagolf on =). This makes me wonder, what's your day job? o.O – justhalf – 2015-08-29T15:08:57.547 4 @justhalf I'm currently in limbo between a master's degree and PhD studies (so I've definitely got too much time on my hands if that was your implication ;)). (This is generally more of a discussion for chat though :)) – Martin Ender – 2015-08-29T16:00:12.773 Pada means when in bahasa Indonesia/Malay. Is that relevant? – XiKuuKy – 2016-10-28T15:28:23.137 @XiKuuKy afaik, the language is called Pada, because it means "falling" in Croatian. – Martin Ender – 2016-10-28T19:41:55.167 And this answer to (see here ). You probably can combine 2 answers in one to describe this wonderful Hello World problem in general. – Vitaliy Kaurov – 2017-09-20T15:30:58.183 30 # Befunge 98, 19 18 Bytes # New answer (from undergroundmonorail) "ck,@!dlroW ,olleH ## Explanation • " starts string mode • Everything that follows is pushed to the stack. The stack is now Hello, World!@,kc • After hitting the end, interpreter go back to the start • It encounters " again, ending string mode • 12 is pushed to the stack (c) • k takes the top value of stack and executes the next command the instruction pointer can see that many times • , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction • @ ends the program The difference with the old answer is that we cleverly reuse the " character by using Befunge's looping behavior when it hits the end of the line. Since it might be less intuitive, I'm letting the old one as well. Also, you may have noticed that the stack will still contains some characters (ck,@) because of this nice trick, leaving some mess if we ever wanted to do something after that. # Old Answer "!dlroW ,olleH"ck,@ This works for funge and befunge 98 ## Explanation • Everything between "" is pushed to the stack. ('H' is now on top.) • c (12) is pushed to the stack • k takes the top value of stack and executes the next command the instruction pointer can see that many times. • , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction • @ ends the program 2I don't think 93 has k – Sp3000 – 2015-08-28T14:30:44.870 @Sp3000 Checked the spec, you are right. I thought that p was missing. It's the opposite. Thanks. – Luke Marlin – 2015-08-28T14:34:40.260 1Well, now that it's 98 only you can use c for 93+. – PurkkaKoodari – 2015-08-28T19:52:40.067 @Pietu1998 Indeed, nice one. – Luke Marlin – 2015-08-31T13:17:38.250 3In 18: "ck,@!dlroW ,olleH – undergroundmonorail – 2015-09-25T19:07:54.227 @undergroundmonorail I have to admit that I don't get the behavior of funge here. Does it empty the stack after hitting @, and interprets what is in it ? – Luke Marlin – 2015-09-28T12:15:39.967 1It hits the " to start the string, adds the entire rest of the line to that string, wraps around and hits the same " to end the string. Now the whole program except that " has been pushed to the stack, with !dlroW ,olleH on top. Then it prints the top 12 characters the same way yours does and stops at @. – undergroundmonorail – 2015-09-28T17:40:30.267 Didn't though of the wrapping around. Great little hack ! – Luke Marlin – 2015-09-29T06:41:23.140 1 For the 18 byte solution, my interpreter produces Hello, World (leading space, no exclamation). The Anarchy Golf interpreter (use form, select Befunge-98, paste code, submit) does the same. – primo – 2015-09-29T12:14:19.517 @primo Weird. It looks like k is executing , 12 times but it's not being executed again when the instruction pointer actually reaches it. Luckily it's an easy fix. – undergroundmonorail – 2015-09-29T12:24:38.200 @Luke The second character should be d, not c. I don't know why but it fixes the bug primo pointed out. – undergroundmonorail – 2015-09-29T12:24:51.923 @undergroundmonorail I don't think that's what's happening. According to the docs any out-of-bounds character defaults to 32. Because one is encountered, as part of a string, it gets pushed to the stack. One could argue that this is a bug, but it seems to be a common one. – primo – 2015-09-29T12:32:35.860 @undergroundmonorail rcfunge gives the correct result with this exact code, and ck, do it 13 times as per the specification – Luke Marlin – 2015-09-29T13:51:07.453 In your explanation, you have a typo. Hello , World!@,kc There's an extra space. I haven't edited because that would be a trivial edit, and I don't have enough rep to do it w/o the review queue. – wizzwizz4 – 2015-12-25T10:10:05.877 even the befunge solution is boring :/ – bobrobbob – 2018-06-11T10:28:54.107 29 # Java, 61 bytes enum H{H;{System.out.print("Hello, World!");System.exit(0);}} This is valid in both Java 5 and Java 6. This won't work in Java 4 or earlier (because enum didn't exist) and will not work in Java 7 or after (because the bypass[1] was "fixed"). enum H { // An enum is basically a class. H; // Static initialization of the mandatory instance, invoking the default constructor. // Happens before the existence check of "main"-method. // No constructor means default constructor in Java. { // Instance initialization block. // Executed in each constructor call. System.out.print("Hello, World!"); // duh! System.exit(0); // Exit before the JVM complains that no main method is found. // (and before it writes on stderr) } } ## Rough equivalence in Java as usually written The above code is roughly equivalent to the following one. class HelloWorld { public final static HelloWorld INSTANCE; static { INSTANCE = new HelloWorld(); } public HelloWorld() { System.out.print("Hello, World!"); System.exit(0); } } ## Proof of correctness java -version java version "1.6.0_45" Java(TM) SE Runtime Environment (build 1.6.0_45-b06) Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode) javac H.java java H Hello, World! 1: The bypass consists of the static execution of code when the class is being linked. Before Java 7, the main-method-containing class was no exception to the static initialization code. Afterwards, static initialization was delayed until the main method would actually be found. I recommend changing the title to “Java 6, 62 bytes” to clarify the version requirement. I’d also like to ask for more detail on the “bypass” fixed in Java 7. – Stevoisiak – 2017-09-20T13:45:40.687 @StevenVascellaro Explanations have been added. – Olivier Grégoire – 2017-09-20T13:57:12.680 5The explanation is much appreciated. I still recommend specifying the language as Java 6 in the title to distinguish it as a unique, version specific language – Stevoisiak – 2017-09-20T14:09:14.407 @StevenVascellaro "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." This is the shortest answer in Java (so far); not writing the version is actually more correct as answer. Plus you're aware of the Java 8 answer, but haven't asked that answer to be Java 8 tagged. Double standard? – Olivier Grégoire – 2017-09-20T14:15:09.173 1@OlivierGrégoire Nice job ;) Also, I changed my program's header to Java 8 when I saw the comments here. – TheNumberOne – 2017-10-09T22:56:40.103 Uh, this is actually 61 bytes – caird coinheringaahing – 2017-11-25T19:51:13.423 @cairdcoinheringaahing Oops, thank you, I fixed it. – Olivier Grégoire – 2017-11-27T14:03:15.570 Isn't stderr ignored on PPCG? Wouldn't that mean that you can remove the System.exit? – NieDzejkob – 2018-03-10T15:53:42.257 @NieDzejkob The challenge explicitly says no to that interpretation. – Olivier Grégoire – 2018-03-10T17:58:45.290 29 # Shakespeare Programming Language, 755 749 715 612 605 592 bytes -34 bytes thanks to jimmy23013 -And a whole 107 bytes more! Wow! ,.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:You big big big cat!Puck:You is the sum ofI the square ofI!Speak thy!You is the square ofthe sum ofI a big cat!Ajax:Remember the sum oftwice twice you a cat!Remember I!You is the sum ofI you!Puck:You is the sum ofyou a cat!Speak thy!You is the sum ofa big cat a cat!Ajax:Speak thy!Speak thy!Remember you!You is the sum ofyou I!Speak thy!Remember the sum ofyou I!Remember you!You big big big big big cat!Puck:You is the sum ofI twice twice you!Speak thy!Ajax:Remember the sum oftwice I a pig!Scene V:.Ajax:Speak thy!Recall!Let usScene V! Try it online! # Non-erroring version, 626 bytes ,.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:Remember I!You big big big cat!Puck:You is the sum ofI the square ofI!Speak thy!You is the square ofthe sum ofI a big cat!Ajax:Remember the sum oftwice twice you a cat!Remember I!You is the sum ofI you!Puck:You is the sum ofyou a cat!Speak thy!You is the sum ofa big cat a cat!Ajax:Speak thy!Speak thy!Remember you!You is the sum ofyou I!Speak thy!Remember the sum ofyou I!Remember you!You big big big big big cat!Puck:You is the sum ofI twice twice you!Speak thy!Ajax:Remember the sum oftwice I a pig!Scene V:.Ajax:Speak thy!Recall!Be you nicer zero?If solet usscene V! Try it online! An improvement over the previous community wiki answer. ### Explanation: ,.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck] #Initialise Ajax and Puck Ajax:You big big big cat! #Set Puck to 8 Puck:You is the sum of I the square of I! #Set Ajax to 8+8*8=72 ('H') Speak thy! #Print 'H' You is the square of the sum of I a big cat! #Set Ajax to (8+2)^2=100 ('d') Ajax:Remember the sum of twice twice you a cat! #Push 2*2*8+1=33 ('!') to Puck's stack Remember I! #Push 'd' to Puck's stack You is the sum of I you! #Set Puck to 100+8 ('l') Puck:You is the sum of you a cat! #Set Ajax to 100+1=101 ('e') Speak thy! #Print 'e' You is the sum of a big cat a cat! #Set Ajax to 3 Ajax:Speak thy!Speak thy! #Print 'll' Remember you! #Push 'l' to Puck's stack You is the sum of you I!Speak thy! #Set Puck to 108+3=111('o') and print it Remember the sum of you I! #Push 111+3=114 ('r') to Puck's stack Remember you! #Push 111 ('o') to Puck's stack You big big big big big cat! #Set Puck to 32 (' ') Puck:You is the sum of I twice twice you! #Set Ajax to 32+12=44 (',') Speak thy! #Print ',' Ajax:Remember the sum of twice I a pig! #Push 2*44-1=87 ('W') to Puck's stack Scene V:.Ajax:Speak thy!Recall!Let us Scene V! #Print and pop repeatedly until Puck's stack is empty (', World!') Impressive. Take another +1. This should win one of ASCII-only's bounties for improving the RosetTIO solutions. – Khuldraeseth na'Barya – 2018-04-09T12:39:06.460 Ah, just noticed the no stderr rule, so the 622 byte version is probably invalid. – jimmy23013 – 2018-04-11T08:43:03.540 @jimmy23013 Eh, we already had 43 warnings in stderr, I think we're good. Very nice work! – Jo King – 2018-04-11T10:17:53.347 @JoKing They were all compiler messages and it was not the program itself writing to stderr. But this time a runtime error. – jimmy23013 – 2018-04-11T10:35:00.613 Let us Scene V works. – jimmy23013 – 2018-04-11T10:42:04.653 @jimmy23013 I've added a non-erroring version – Jo King – 2018-04-11T10:54:19.853 For some reasons nobody has noticed yet you had a "remember me" instead of "remember I" in the non-erroring version. – jimmy23013 – 2019-06-12T02:53:44.037 Right, weird... >.< – Jo King – 2019-06-12T03:10:05.457 29 # Java 8, 76 bytes Thought I would try to beat Geobit's answer :) interface A{static void main(String[]a){System.out.print("Hello, World!");}} Try here! 28 # Pyth, 14 bytes "Hello, World! Doubt it'll get smaller than this in Pyth. 17This also works in TI Basic – Patrick Roberts – 2015-09-08T19:40:18.313 I checked all nine zlib.compress levels with [len(zlib.compress("Hello, World!",i))+2 for i in range(10)] .Z"compressed text isn't more efficient for any level. – Tornado547 – 2017-11-28T16:51:28.930 28 # Python 2, 20 bytes print"Hello, World!" Python 2 is better for printing than 3 :D 29Just in case anybody is wondering: import __hello__ prints "Hello world!", which is incorrect punctuation for this challenge. – Sp3000 – 2015-08-28T15:11:29.577 7 @Sp3000 Yeah, I looked into it. It actually prints Hello world... (tested on repl.it. You're thinking of Python 3, which has a different result. – mbomb007 – 2015-08-28T15:13:51.863 @mbomb007 Ah, I didn't realise Python 2 and Python 3 had different __hello__ messages, indeed I tested on the wrong one. – Sp3000 – 2015-08-28T15:18:09.363 Python 2.7 prints Hello world... \o/ What is this!!! – Zizouz212 – 2016-09-16T01:37:57.090 27 # Brainfuck, 92 (hirose) ->+++++>>>+>+>+>-->>++[+++[>++++++++<-]<+]>>.-[>->>>>>[+<]>--]>+>--.->---..>+++>.>>>++++[.<] This is a slight modification of hirose's 92-byte solution for the lowercase-w version of the problem on Anarchy Golf. Changing ++ to -- conveniently subtracts 32 from the cell that holds w, turning it into W. # Brainfuck, 95 ->>++>+++>+>---->--[++++++[>+++++++++++<-]-<+]>>----.>+++.>-..+++.>>>.<.<.<.+++.------.<-.>>>+. For this solution, I used code that I wrote for this problem on SPOJ and touched up the output a bit by hand. Note: Both solutions are compatible with Alex Pankratov's bff (brainfuck interpreter used on SPOJ and ideone) and Thomas Cort's BFI (used on Anarchy Golf). Here's the variant for a brainfuck derivative, oOo code: http://pastebin.com/BqNcDnm7 I'm not sure if it deserves its own answer. (It's based on the 92-char one you posted) – JNV – 2015-08-30T08:41:11.580 What is the advantage of the 95-byte solution? Why mention it at all? – anatolyg – 2015-08-31T14:29:52.880 2 @anatolyg The 92 is my modification of hirose's solution. The 95 is another solution that I developed from scratch. If you can't see the value of mentioning alternative approaches, or of distinguishing your own work from (trivial or non-trivial) modifications of someone else's code, I don't know what to say. This type of thing is standard practice on Anarchy Golf, and I'd be happy to see it catch on here as well. Incidentally, I've been informed that the 95 translates to 97 in ???, while the 92 translates to 98. – Mitch Schwartz – 2015-08-31T16:04:57.097 (I was misinformed; it's 95 -> 96 and 92 -> 97 for ???.) – Mitch Schwartz – 2015-08-31T20:29:06.737 25 ## Stack Cats, 134 + 3 = 137 148907 bytes I'm happy to give a 500-rep bounty to the first person who can bring this down below 100 (+3) bytes. -*(:^-_-_:-_:-_:-_:-_-_:[:^]]:^!-*!->[!_>[!_>[{]>[^-_-_:]]<<<}>[!-:^[[\\>]:^[[>:[>:^[<<]]\\>[*>+:^:-_]:^[[-_*[>>>[-_[/<]>+^[>[<<]]*>[) Needs to be run with the -l switch of the Ruby interpreter, hence +3 bytes. Try it online! There's definitely still room for improvement here, but I haven't quite figured out myself yet how to program in this language effectively. The current solution was just a general idea for how to approach the challenge and I just wrote the code in a rather ad-hoc way. Even without changing the overall approach I'm confident that one can end up much closer to 100 bytes or even below. ### Explanation Proudly introducing my latest creation, this time in collaboration with Sp3000. :) The idea for this language was originally born for feersum's language design CnR, but at the time we weren't able to figure out whether this idea was usable, and then kept putting it off. A couple of weeks ago we decided to revisit the idea, cleaned up the design a lot and managed to make progress towards proving its Turing-completeness, so here it is. Stack Cats is a stack-based, reversible programming language. In fact, in order to undo any piece of code, you simply mirror it (which means reversing it and swapping all brackets and slashes). Furthermore, every program has to have mirror symmetry itself. This implies that every non-trivial program has odd length and the form f g f-1, where g is a single very simple command which is also an involution. That makes programming and especially golfing in Stack Cats fairly tricky. Note that the source code above isn't actually symmetric. This is because the -l switch lets you omit the first half (before the g), since it's redundant in any valid program anyway. So the full program is actually: (]<*[[>>]<]^+<[>$_-]<<<]*_-]]^:[_-:^:+<*]<//[[>>]^:<]:<]]^:[<//]]^:-!]<{>>>[[:_-_-^]<[}]<_!]<_!]<-!*-!^:[[^:]:_-_-:_-:_-:_-:_-_-^:)*-*(:^-_-_:-_:-_:-_:-_-_:[:^]]:^!-*!->[!_>[!_>[{]>[^-_-_:]]<<<}>[!-:^[[\\>]:^[[>:[>:^[<<]]\\>[*>+:^:-_]:^[[-_*[>>>[-_[/<]>+^[>[<<]]*>[) When I say "stack-based", I mean that the memory model is actually a tape of stacks. As in my other stack-based languages, each stack is initially implicitly filled an infinite amount of zero (this time, that was actually necessary to ensure full reversibility of all commands on all possible states). In addition to this the initial stack starts with a -1 on top when there is no input (which is the case here). Output in Stack Cats works simply by printing the contents of the final stack, top to bottom. So the goal is to generate a stack with the following values (top is right): 33 100 108 114 111 87 32 44 111 108 108 101 72 (There are a few other options but this is what the above program does.) I'm going to represent the tape as follows, with the v indicating the tape head's position: v ... -1 ... 0 Now on to the code. Note that the program begins with a (...) which continues until just before the central *-*. This is a loop, which can be used as a conditional. The loop is entered and exited only when the top of the stack is positive. Since the initial stack holds a -1, the entire first half of the program is skipped. This makes programming a lot easier, but of course it's also somewhat wasteful in terms of golfing. I haven't yet been able to figure out how to make easy use of both halves of the code except for simple toy problems. Next comes the *-*. Here, * takes the top of the stack XOR 1, i.e. turns -1 into -2, the - negates it to give 2 and then we have another *, giving 3. Now that the top of the stack is positive, we do enter the (...) in the second half. The code in there will be executed only once and now turns this single 3 into the stack we need for the output. It turns out that the quickest way to obtain large numbers without loops is a Fibonacci-like progression where we repeatedly add the last value to the one before. I say Fibonacci-like because we have some flexibility here since we can occasionally increment or decrement values in the process, or add the last value to the previous one several times before swapping their roles. For now, we're trying to compute 33 and 87, because they both appear in the same Fibonacci-like sequence. (And they are the character codes of ! and W.) If the top of the stack is a and the value below is b, I'll be writing this as (a, b), so the current state is (3, 0). Let's go: : Swap the top two values. ( 0, 3) ^ XOR the second into the first. ( 3, 3) - Negate top. ( -3, 3) _ Subtract top from second. ( 6, 3) As you can see, -_ can be used to add the second-to-top to the top. -_ Add second into top. ( 9, 3) : Swap. ( 3, 9) -_ Add second into top. ( 12, 9) The last two together form a normal "Fibonacci step". :-_ Fibonacci step. ( 21, 12) :-_ Fibonacci step. ( 33, 21) :-_ Fibonacci step. ( 54, 33) -_ Add second into top. ( 87, 33) : Swap. ( 33, 87) Now [ pushes the 33 one stack to the left (moving the tape head along), :^ duplicates it and ] moves one copy back. Together, this just puts a 33 on the stack to the left. And then ]:^ moves the 33 to the right and duplicates it again there. So now we've got: v 33 ... 33 87 33 ... 0 0 0 Next, it turns out that most of the lower case letters are multiples of 3 and their other factors are 36, 37, 38 which aren't too far away. 99 is also useful, since we'll need both 100 and 101, so we now create a stack with those factors so we can multiply all of them by 3 later. Stack Cats doesn't have a decrement or increment command. The standard way to increment a value is to combine bitwise NOT (!) and unary negation (-). However, if we know that our value is even we can also increment by toggling the least significant bit with *. Hence, the following !-*!- brings the 33 on top of the stack up to 36. Next, we pull over two 0s from the empty stack to the right, turn use them to get incremented copies of the 36 with >[!_>[!_. The tape now looks like this: v 38 37 36 ... 33 87 33 ... 0 0 0 Time for the loop: >[{]>[^-_-_:]]<<<} Besides the (...) we've already seen, Stack Cats has another loop, {...}, but its semantics are also a bit unusual. The loop body is always executed at least once. When the loop starts, Stack Cats remembers the value on top of the stack, and then the loop doesn't terminate until that value is seen again at the end of an iteration. That means the easiest way to work through a stack is to put a zero on top and then shift the stack away one value at a time until we hit the zero at the bottom. Here is what the loop does: >[ Fetch a zero from the empty stack to the right. { Loop until zero... ] Push the current factor X to the right. >[ Fetch a zero from the stack next to that. ^ XOR X into that zero, duplicating X. -_-_ Add X into the new value twice, computing 3*X. : Swap 3*X and X. ]]<< Push X two stack to the right and return. < Move back to the stack we're looping over. } > Move onto the stack which now holds the multiples. This is the new tape: v 99 33 108 36 111 37 ... 33 87 114 38 ... 0 0 0 0 0 0 The next bit is [!-:^ which you've seen before: it increments the 99 to 100 and duplicates it on the empty stack next to it. The [[ moves one of those 100s over onto the 33 — we're now starting to build the final stack there. Here's what we've got: v 33 108 36 100 111 37 ... 33 87 100 114 38 ... 0 0 0 0 0 0 It's going to be annoying to fetch all the values from so many stacks away, so here's a new command. \ swaps the current stack with the one of the right, moving the tape head along. So the \\ now brings the output stack closer to the useful values: v 33 108 36 100 111 37 ... 87 100 33 114 38 ... 0 0 0 0 0 0 Next, there's >]:^ which moves the 108 onto the empty stack to duplicate it. [[>:[ moves one of them and the 114 onto the output stack. >:^[ duplicates the 111 and moves one copy onto the output stack. Then we fetch the 87 with <<]], and move the stack two positions further with another \\. We've now got World!: v 87 111 114 33 108 36 100 37 ... 100 111 108 33 38 ... 0 0 0 0 0 Time for the space: we've still got that 33 around, so we fetch and decrement it with >[*. We don't need those 36, 37, 38 any more, but we do need a 44. We also still need the 72 for the H later on, and we can actually compute that on the way. All of this is accomplished with the following code: >+:^:-_]:^[[-_*[>>>[-_[ The new command here is + which swaps the top of the stack with the third value from the top. We use it together with : to put the 36 below the 37 and 38. The ^ replaces the 37 with 37 XOR 38 which is 3. We then add this to 38 with :-_ which gives 41. ]:^ duplicates that on the stack to the right. Then we add a 32 into it with [[-_ and decrement it with * by toggling the least-significant bit. Voilà, there's our 72. We move it to the side with [, go back to the other copy of 41 with >>> and add another 3 into it with [-_ before putting it on the output stack with [. Next, we move the current stack to the left with /. Here's the current tape: v 44 32 87 111 114 108 100 72 3 ... 100 111 33 108 36 ... 0 0 0 0 0 Now all that's left is collecting a few more values with <]>+^[>[<<]]*>[ The <] fetches the 111. Then >+^ swaps the 72 with the zero below in order to duplicate the 108. [>[ moves both of those onto the output stack. <<]] fetches the 100 and * turns it into a 101. Finally >[ gets the 72 and we're done. If you've actually followed all of this you'll noticed that there's tons of stuff we could have done differently which may or may not have saved bytes. There are many more ways to compute the different numbers, maybe XOR would have been useful more often. We could also generate some larger or negative numbers, since the final values are taken modulo 256 before being printed. We could also have made more use of loops, or used the stacks differently. There are also further stack manipulation commands like | to reverse it, X to swap the stacks left and right and = to swap only their top values. As difficult as it is to program in Stack Cats, it still provides quite a large set of useful commands, which allow for many different approaches to any given problem. 1Crazy language, very nice answer. – Razetime – 2018-04-28T09:27:54.830 24 # Python 3, 22 bytes print("Hello, World!") In Python 3, printing is a function and so it requires parenthesis. A 16 byte solution would be import __hello__, but annoyingly this prints the message without the comma! 3Don't forget wrong caps :P – CalculatorFeline – 2017-06-20T21:24:27.823 24 # Jelly, 8 bytes “3ḅaė;œ» Try it online! 1Wat. How on earth did you compress it so much... – ETHproductions – 2016-01-11T15:42:34.120 6Jelly now has an experimental decompressor that indexes an English dictionary. – Dennis – 2016-01-11T16:00:39.227 17Jelly is ḅaė. – mbomb007 – 2016-02-24T19:54:52.223 2you mean: ḅaė is jelly – Daniele D – 2016-08-12T09:06:47.000 23 # Javascript (ES6), 20 bytes alertHello, World! Javascript ES6 features are awesome when it comes to code golf! Here, the use of templates allows for a two byte savings by removing parentheses. How it works This syntax is known as tagged templates, and it is not the same as merely calling a function with a single string as a parameter, as I initially thought. The function, in this case alert, is called with an array of the string portions of the template and an array of the inserted values. Since there were no inserted values and only a single string portion of the template, alert is called with the array ["Hello, World!"] as its sole (defined) parameter. alert displays this, conveniently, as Hello, World! Try replacing alert with console.log, and it won't work! You'll get Array [ "Hello, World!" ] instead, since the console doesn't follow the same display rules as alert. wait, but alert does not print to STDOUT? – an earwig – 2015-08-30T23:38:53.820 5@James_Parsons Since JavaScript doesn't really have a traditional STDOUT, alert is typically considered acceptable. – jrich – 2015-08-30T23:41:31.307 oh, ok sorry. I'm kinda new here – an earwig – 2015-08-30T23:49:22.793 1@James_Parsons No problem. Welcome to PPCG! – jrich – 2015-08-30T23:50:18.403 6console.log("Hello, World!") (28 bytes) outputs to STDOUT if run in node. – jib – 2015-09-05T19:20:39.453 4 You may use Javascript Shell and change alert to print which will print to STDOUT. – tsh – 2015-09-08T06:27:45.033 22 # Hexagony, 23 bytes H;_\/201;lQP/oe;/W_|@dr Try it online! ---- This was found with a brute force program. Time taken: In 0 days 0 hours 52 minutes 56.4935 seconds I suspect this is optimal. 1I was hoping it wouldn't be brute-forced, but you still get the bounty – Jo King – 2018-05-19T13:56:55.783 3@JoKing I was hoping it would be :D ... I've been meaning to write a brute forcer for linear programs for ages and never got around to it, so I'm glad someone finally did. – Martin Ender – 2018-05-19T13:57:29.807 3Any plans on posting the brute-forcer as well? – Jo King – 2018-05-20T00:29:25.980 1@JoKing Before posting the brute force program, I need to optimize it and make sure that it doesn't produce a shorter solution in a reasonable amount of time. – user202729 – 2018-05-20T13:17:35.487 1I'm quite impressed by this backwards code the brute force has worked out, where it uses each ; at least twice in passing, and twice again when the paths cross over – Jo King – 2018-05-20T13:51:58.550 @user202729 did you ever get around to posting the brute forcer – ASCII-only – 2018-12-26T01:04:18.953 @ASCII-only It's linked right there – user202729 – 2018-12-26T02:27:07.843 22 # Common Intermediate Language, 126 123 bytes .assembly H{}.method static void M(){.entrypoint ldstr"Hello, World!" call void[mscorlib]System.Console::Write(string) ret} With proper indentation: .assembly H {} .method static void M() { .entrypoint ldstr "Hello, World!" call void[mscorlib] System.Console::Write(string) ret } You can save 2 bytes by removing unneccesary newlines (at least in Mono) – ASCII-only – 2018-04-20T01:24:02.627 20 # Wordy, 1666 bytes xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx x x x x x x x.xxx xxx xxx x x.xx x.x x x x x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x.xx x.x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x.xx x.x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x.xx x.x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x x.xx x.x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x.xx x.x. We can greet the World by executing the following instructions: ASSIGN NOP LITERAL 16 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 4 LITERAL 8 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 5 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 12 OUTCHAR MULTIPLY VALUE NOP LITERAL 2 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 5 LITERAL 7 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 7 LITERAL 2 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 4 OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 1 Wordy encodes all instructions as sentences, where the fraction of words that are longer and shorter than the rounded average selects the command. The shortest sentences I could find for the used instructions are: ASSIGN xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx x x x x x x x. VALUE xxx xxx x x x. ADD xxx x x. MULTIPLY xxx xxx xxx x x x x. OUTCHAR xxx xxx xxx x x x x x x x. NOP xxx xxx xxx x x. LITERAL xx x. 19 # Hot Soup Processor, 17 bytes mes"Hello, World! This one's pretty straightforward, but I'm not aware of any other language which can use mes ("message") to print. The language itself is actually of Japanese origin, as one can tell from their website. Apparently the closing quote isn't necessary (as of ver 3.4a), which is unusual for a non-esolang. 10"HSP is a development language of the interpreter type. The world can be constructed by expanding the wing of the creation." Did you expand the wing of the creation? – 2xsaiko – 2017-01-29T21:15:07.190 19 # IRC, 27 bytes /nick h /quit Hello, World! The esolangs page comes with a really lengthy two-file "Hello, World!" example. It turns out that is completely unnecessary. The main file of an IRC program contains the program name, a list of channels (which are found in separate files and define individual threads) as well a generic error message which is displayed for various errors. However, that error message can be anything and goes to STDOUT. So let's define our error message as Hello, World!. The shortest way to raise an appropriate error is simply not to define any channels. Voilà, almost 800 bytes saved. 6You know some of the weirdest esolangs. – kirbyfan64sos – 2015-09-03T23:47:58.723 Does it print to STDERR? – minmaxavg – 2016-07-01T00:02:39.140 1@minmaxavg it's been a while, but since I explicitly mention it in the explanation I'm pretty sure that I checked that the error message goes to STDOUT and not too STDERR. – Martin Ender – 2016-07-01T05:49:00.987 19 # Minecraft 1.8.7, 26 + 2 = 28 Blytes This is using this version of byte counting. The command block contains the code: tellraw @a "Hello, World!" This one doesn't really need an explanation. Use a button instead on this one. – SuperJedi224 – 2015-11-13T00:42:07.037 2This scoring method is called blytes (blocks + bytes). – user48538 – 2016-01-10T15:45:19.700 @zyabin101 I know - I created the term. I hadn't updated it though. :P Thanks. – Addison Crump – 2016-01-10T17:58:04.840 24You couldn't have taken a screenshot during the day? – mbomb007 – 2016-02-24T19:57:05.343 17 # Wierd (John's), 432421302289256225197 181 bytes -******************* !dlroW ,olleH * R* * * * E* ** ** * T* ** ** * U *** *** **** R * * * * N * * ******** * **** 0 ** Try it online! ### Background Wierd's workspace determines both code and data. While each character sets the workspace's cell to its code point (missing characters are treated as spaces, which have code point 32), the code is defined by a particle that starts in the upper left corner and moves along a wire. This wire is also defined by the characters: non-spaces form wires, spaces separate these wires. Instructions are encoded into the kind of turns the particle takes. At the beginning, the upper left corner holds the number 45, which is the x-coordinate of the cell to the right of !dlrow ,olleH. Each loop through the asterisks that form the main wire decrements that coordinate, prints the character, then prints the character it points to. After all 13 characters have been printed, the upper left corner becomes a space, causing the particle to traverse RETURN 0 instead of the main wire. Once 0 is reached, the particle can no longer move; the program ends. For the first 12 iterations, the particle moves as follows. <style>body,html,svg{display:block;height:100%;margin:0;padding:0;}</style> <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 210 105"><path d="M 20 80 L 20 100" fill="none" stroke="#FFC0C0" stroke-width="3"/><path d="M 20 8.5 L 20 80" fill="none" stroke="#C00000" stroke-width="3"/><path d="M 20 98.5 L 20 101.5" fill="none" stroke="#C00000" stroke-width="3"/><path d="M 180 30 L 200 10 L 199 10" fill="none" stroke="#C0C0C0" stroke-width="3"/><path d="M 200 10 L 10 10 L 30 30 L 30 50 L 40 60 L 60 60 L 70 50 L 70 30 L 60 40 L 60 70 L 50 80 L 50 90 L 60 100 L 70 100 L 80 90 L 110 90 L 90 70 L 100 60 L 120 60 L 130 50 L 130 40 L 120 30 L 120 70 L 130 80 L 200 80 L 180 60 L 150 60 L 180 30" fill="none" stroke="#000000" stroke-width="3"/><path d="M 10 10 L 30 30 L 30 50 L 40 60 L 60 60 L 70 50 L 70 30 L 60 40 L 60 70 L 50 80 L 50 90 L 60 100 L 70 100 L 80 90 L 110 90 L 90 70 L 100 60 L 120 60 L 130 50 L 130 40 L 120 30 L 120 70 L 130 80 L 200 80 L 180 60 L 150 60 L 180 30 L 200 10 Z" fill="none" id="move-loop"/><circle r="4" fill="#00C0C0"><animateMotion dur="10s" repeatCount="indefinite"><mpath xlink:href="#move-loop"/></animateMotion></circle></svg> However, during the thirteenth and last iteration, the upper left corner if removed, so the particle moves down the red wire instead. ### Code As illustrated in the Stack Snippet, the particle takes the following left turns on the main wire. • 315° Subtract. Nothing is done, since the stack is empty. This turn, like the other no-ops, is made solely to save space. • 45° Push 1. STACK: [1] • 45° Push 1. STACK: [1 1] • 45° Push 1. STACK: [1 1 1] • 45° Push 1. STACK: [1 1 1 1] • 135° Pop the stack. Since the popped element is 1, pop two more values (1 1) and push the code point of the character at those coordinates. STACK: [1 n] Initially, the character at (1, 1) is -, so n = 45. • 45° Push 1. STACK: [1 n 1] • 315° Subtract. STACK: [1 (n-1)] • 45° Push 1. STACK: [1 (n-1) 1] • 45° Push 1. STACK: [1 (n-1) 1 1] • 45° Push 1. STACK: [1 (n-1) 1 1 1] • 45° Push 1. STACK: [1 (n-1) 1 1 1 1] • 315° Subtract. STACK: [1 (n-1) 1 1 0] • 135° Pop the stack. Since the popped element is 0, pop two more values (1 1) and store the next value on the stack (n-1) at those coordinates. STACK: [1] During the first run, the upper left corner changes from - (45) to , (44). During the thirteenth and last run, the upper left corner changes from ! (33) to space (32), essentially cutting the wire. • 270° Pop the stack. Since the popped element is 1, continue. STACK: [] • 315° Subtract. Nothing is done, since the stack is empty. • 45° Push 1. STACK: [1] • 45° Push 1. STACK: [1 1] • 45° Push 1. STACK: [1 1 1] • 135° Pop the stack. Since the popped element is 1, pop two more values (1 1) and push the code point of the character at those coordinates. STACK: [(n-1)] • 45° Push 1. STACK: [(n-1) 1] • 45° Push 1. STACK: [(n-1) 1 1] • 135° Pop the stack. Since the popped element is 1, pop two more values (1 (n-1)) and push the code point of the character at those coordinates. STACK: [c] During the first run, this retrieves the character at (44, 1), which is H. • 45° Push 1. • 225° Pop the stack. Since the popped element is 1, pop the next item and print it to STDOUT. STACK: [] • 180° Jump to the rightmost star on the first line. • 135° Get/set. Nothing is done, since the stack is empty. After this turn in the upper left corner, the particle starts over. That is amazing. I couldn't figure out how to exit the loop and settled for doing it the long way - big mistake. – Jerry Jeremiah – 2017-10-09T09:39:21.017 17 # GOTO++, 31 bytes s=«Hello, World!» GOTOPRINT() This one is actually a bit interesting. There is a more intuitive way to output things in GOTO++, which would be this: GOTOPRINTDUTEXTE()«Hello, World!» This is however 35 bytes. GOTOPRINTDUTEXTE outputs its arguments to STDOUT (Du texte means some text in french). Note that the arguments of a function don't necessarily have to be inside the brackets, as long as they are to the right of the left bracket. So GOTOPRINTDUTEXTE()«Hello, World!» is just as valid as GOTOPRINTDUTEXTE(«Hello, World!») GOTOPRINT() on the other hand, outputs to STDOUT the very last variable modified by a =. 17 # Starry, 191188186182172 169 bytes + + +* + * + + +* + .* + + +* * + +* . + + . + . + + + +* + . + + * +* + . + + * +* . +* + * . + .* . . . + * . This is almost definitely suboptimal, but Starry golfing is surprisingly difficult, due to the cost of pushing a number being higher than that of performing an operation. Thankfully we can reuse a lot of past computations, due to duplicate letters in the message "Hello, World!". Starry operators are determined by the number of spaces before one of +*.,. The relevant ones used are: Spaces Char Operation ----------------------------------------------------- 1 + Duplicate top of stack 2 + Swap top 2 stack elements 3 + Rotate top 3 stack elements n >= 5 + Push n-5 to stack 0 mod 5 * Add 1 mod 5 * Subtract 2 mod 5 * Multiply 1 mod 2 . Output as ASCII And here is the program broken down: Line Explanation Stack Out ------------------------------------------------------------------------------------- + + +* + * + Push 3 and 36, dup [3 36 36] + +* + . Dup, x2, dup, print [3 36 36 72] H * Add [3 36 108] H + + +* * + Dup, sub 8, dup [3 36 108 100 100] H +* . Add 1, print [3 36 108 100] He + + . Swap, dup, print [3 36 100 108] Hel + . Dup, print [3 36 100 108] Hell + + + Dup, push 3, dup [3 36 100 108 108 3 3] Hell +* + . Rot 3, add, dup, print [3 36 100 108 3 111] Hello + + * +* + . Dup, //5*2, dup, print [3 36 100 108 3 111 44] Hello, + + * +* . Print 32 [3 36 100 108 3 111 44] Hello, +* + * . Double, sub 1, print [3 36 100 108 3 111] Hello, W + . Dup, print [3 36 100 108 3 111] Hello, Wo * . Add, print [3 36 100 108] Hello, Wor . . Print, print [3 36] Hello, World + * . Swap, sub, print [] Hello, World! 17 # Piet, 93 codels The 1 pixel bitmap of the 31x3 program : There might be still some room for improvement. But the Direction Pointer & Codel Chooser are not making things easier. This is the 12 codel image : ## Remarks : Because of the upper-left black codel, npiet online seems to have a problem with it. But it works on PietDev. PietDev should be used with caution because it ignores some specs. The black start codel problem is one of them. The other is wrong behavior for the DIV operation that generates float values although the spec says that all values in Piet are integers. Npiet is a good way to check if a program really works. – M L – 2015-09-08T17:33:26.970 1Yes, I noticed that after I posted this solution. The div problem on PietDev is not a problem if you just use it for output, since that only uses the integer part. And i.m.h.o., I do believe it would be an enrichment to npiet if it allowed to start with black codels till another colour is found. You could write piet programs with a black frame that way. – LukStorms – 2015-09-09T07:45:29.163 I'm awarding the bounty to this submission, despite the black codel. The reuse of 2 and 3-large cells is very nice - I thought I'd try golfing this down a column or two but it's surprisingly hard. Makes me think 87 might be possible though. – Sp3000 – 2015-09-09T07:56:38.000 @Sp3000 Thanks for the bounty reward. I've been trying to find a solution without the black codel that's below 30x3. But can't seem to find one. But I still believe there should exist a 29x3 solution. Piet is just a immense pain to golf. It's not just a matter of getting the optimal result from the stack. – LukStorms – 2015-09-14T21:24:52.270 17 # Cheddar, 20 bytes print"Hello, World!" Yes!!!!! I have been waiting for this day a long time. After days of banging my head on my desk trying to get Cheddar to work. I have finally made a Cheddar REPL. The REPL is very alpha, so if you'd like to test it out, ping me in chat @Downgoat Update: To run simply go to cheddar.vihan.org and follow the download instructions Update 2: Use the experimental online REPL at: cheddar.vihan.org/repl 3-1 Language name makes me want cheese ;) – Beta Decay – 2016-08-15T20:22:39.993 16 ## Funciton, 212 209 bytes ╔══════════╗ ║2388215291╟ ║3945970717║ ║0943959830║ ║0709090713║ ║3592077341║ ║6068961777║ ║8210571695║ ║52834632 ║ ╚══════════╝ I found that 10 digits per row yielded the least bytes, although there may have been a mistake in my calculations. 16 # Piet, 15x15(225) 13x15(195) codels I think Piet program size is counted by codels. If someone wants to know the size in bytes anyway, I could shrink it down to 495 bytes(15x15 codels) and 476 bytes(13x15 codels) using PNGGauntlet. Codel size 10 for better visibility. 13x15 version: First version (15x15): I was a bit lazy with this solution. I should be able to golf it down a bit more. This solution fills up the stack with ASCII-32 and reads it out in a loop (ASCII+32). Output: D:\codegolf\Piet\npiet-1.3a-win32>npiet "Hello World codegolf.png" Hello, World! D:\codegolf\Piet\npiet-1.3a-win32> 16 # Brain-Flak, 142140 136 bytes ((((((((((((()()){}){}){}){}()))){}{}())([][]){})[][])[[]]())[((()[]){}){}])([()[]](([]([](((([][]))([]{}{})))[]{}[])[[]])))(([][][]){}) Try it online! In the time since this answer was originally posted (original code below) Jo-King wrote a computer program that was able to find a shorter Hello World. After careful examination I was able to shave 2 bytes off of the computers program. Jo-King then improved his program to outgolf me. But I'm not beaten that easily and I've golfed it back, taking another 2 bytes off the machine. I won't explain the entire program because I don't understand it and Jo-King has already done that in the linked post but I will explain my golf. My golf pertains the part that looks like: ([][]([](()[][]){})) From here I noticed that [][] was repeated twice. I thought it might be a good idea to cache this value instead: (([][])([]((){}){})) However because there is a [] between the push and the pop this is off by one. We can fix this by moving the () outside of the double to decrease by 1. (([][])([]()({}){})) At this point we can increase the [] in between by another one by pushing [][] twice instead of once ((([][]))([]{}{})) This saves 2 bytes. A man ain't nothin' but a man, And before I'll let your [metagolfer] beat me down, I'll die with the [keyboard] in my hand. # Original code, 148 bytes Now that DJMcMayhem's answer has depreciated. I made a replacement (and even removed a few bytes). (((((((((((()()()()){}){}){}()))){}{}())[][][][])[][])[[]]())[[][][][][]]())([([]([])[][]{})]()()()([[]](([()()()]([([][][])](((({}()){}))){}{}))))) Try it Online! ## Explanation This explanation was create by Poke ( ( ( ( ( ( ( ( ( ( (()()()()){} Add 8... to 0 ){} Double to 16 ){}() Double and add 1 to 33 which is ! ) Push the ! to save it for the end ) Push an extra 33 to help add to get to the first letter ){}{}() Triple the 33 and add 1 for 100 which is d )[][][][] Push the d to save it for the end. Add height-2, 4 times for 108 which is l )[][] Push the l to save for the end then add height-3, 2 times = 114 which is r )[[]]() Push the r to save for the end then subtract height-4 and add 1 = 111 which is o )[[][][][][]]() Push the o to save for the end then subtract height-5 5 times and add 1 = 87 which is W ) Push W to save for the end At this point the stack contains "!dlroW". 87 Floating ( We're now a level lower so we start at 0 for the math here. [([]([])[][]{})]()()() Push 6+6+7+7+6=32 which is the space, then negate it + 3 = -29 Floating ( [[]] negate height-7 = -7 Floating ( ( [()()()] -3 Floating ( [([][][])] Push 3*height-7 = 21 and negate it = -21 Floating ( ( ( ({}()){} 21+1+22 = 44 which is the comma ) Push the , to save for the end ) Push another 44 ){}{} 44+44+44 = 132 ) Push 132 plus the -21 we left floating earlier = 111 which is o ) Push 111 plus the -3 we left floating earlier = 108 which is l ) Push another l ) Push 111 plus the -7 we left floating earlier = 101 which is e ) Push 101 plus the -29 we left floating earlier = 72 which is H At this point the stack contains "!dlroW ,olleH" and our accumulator is at 159 which doesn't get used. 4 Here's an explanation... It's not great. I don't know the proper vernacular for this language. Try it online! – Poke – 2017-04-12T14:37:18.930 15 # ><>, 23 bytes "!dlroW ,olleH"l?!;oe0. ><>, or "Fish", is a 2D stack-based language like Befunge. Here's the breakdown: [setup] " Start string parsing !dlroW ,olleH Push each of these chars one-by-one onto the stack " Stop string parsing [main loop] l?!; If the length of the stack is 0, halt o Otherwise, output the top of the stack as char e0. Jump back to just before the l 15 # FiM++, 88 bytes Dear Princess Celestia:H.Today I learned:I sang "Hello, World!".Your faithful student,M. FiM++ is an object-oriented language inspired by My Little Pony: Friendship is Magic. Yeah, right. Printing "Hello, World!" is fairly straightforward, and there was an example in the interpreter's repository which I used as the basis for the above code. The main golfing steps were figuring out which parts could be shortened or left out and which couldn't... and the fact that I could replace I wrote ... with I sang .... The interpreter prints a bunch of diagnostic information before running the code, but that does not appear to be part of the actual language specification. 15 # Wierd, 1341 bytes Unlike other languages where the symbols in a program determine which instructions are executed, in Wierd, it is the bends in the chain of arbitrary symbols that determine which instructions are executed. From the website: First, a Riddle: Q: What do you get when you put three marginally-sane programmers on a mailing list with the Befunge and BrainF*** programming languages? A: You get BeF***, and then they get Wierd. ... Chris Pressey then jumped on it, created the angle-to-instruction mapping, and christened the entire mess "Wierd"--a cross between the words "weird" (which the language seemed to be) and "wired" (which would describe the appearance of programs written in the language). Try it online at http://catseye.tc/installation/Wierd_(John_Colagioia) EDIT: Dennis has killed this answer quite thoroughly with this Even though this is much smaller than the sameple that comes with the interpreter I am positive this can be golfed more (and it has been - by Dennis) Please try to come up with something smaller and edit the question with that version. ,!dlroW ++ o # ++ + l ++ + ++++ l +++ ++ ++ + e + + ++ ++ + + H + + ++ ++ + + + + ++ ++ +++ + ++++ + ++ + + ++ ++ + +++++++ +++ ++ + ++ + + + ++ + ++++ + + + ++ ++ + + + ++ ++ + + + ++++ + ++ + + + + ++ +++ + +++++++ ++ + +++ + + + + ++ ++ + + + ++ + + + + + ++ + ++++ + + + ++++ + ++ + + + + + ++ + + + + + +++++++ + + ++++ + ++ + +++ + + + + +++++++ +++ + ++ + + ++ + + ++ + ++++++++++++ ++ ++ ++++ + + + ++ ++ + + ++++ + ++ ++ +++++++ + + ++ + + ++ + + ++ + + ++ + ++ +++ + ++ + + +++++++ ++ + + + + ++ + + ++++ ++ ++ ++++ + + ++ + + + + ++ +++++++ + + ++ + ++++++ +++++++ +++ ++ + + + ++ + + ++++ ++ + + + + + ++++ ++ ++++ + ++ + + + +++++++++++ +++++++ ++ 1Nice job! I was hoping someone would beat the official HW example eventually. :) – Martin Ender – 2016-01-12T09:15:57.993 I wonder if they misspelled "weird" intentionally... – mbomb007 – 2016-02-24T19:58:22.800 1 @mbomb007 Yes. The web page http://catseye.tc/view/wierd/dialect/wierd-jnc/doc/wierdspec.txt says that Chris Pressey then jumped on it, created the angle-to-instruction mapping, and christened the entire mess "Wierd"--a cross between the words "weird" (which the language seemed to be) and "wired" (which would describe the appearance of programs written in the language) – Jerry Jeremiah – 2016-02-24T20:12:29.817 14 # Zsh, 17 bytes <<<Hello,\ World! 14 # Fortran, 28 bytes print'("Hello, World!")' end You can't write print*,"Hello, World!" because there's a leading space in the default print format. Thus, we pass in our own format that simply contains a constant string. Which version of Fortran is this? In F77 you'd need some spacing if I'm not mistaken. – Robert Benson – 2016-07-19T12:37:05.003 @RobertBenson F77 would also require fixed form if I'm not mistaken. In any case, this works in GFortran. https://tio.run/##S8svKilKzNNNT4Mw/v8vKMrMK1HXUPJIzcnJ11EIzy/KSVFU0lTnSs1L@f8fAA – Dennis – 2017-06-06T06:24:55.923 Yes, F77 is fixed format, so you'd need some tabs, which adds to byte-count :( – Robert Benson – 2017-06-07T15:10:32.610 GFortran: print*,"Hello, World!";end 26 bytes, but it prefixes a space char :( – roblogic – 2019-08-27T09:55:43.780 14 # Alchemy, 1013 bytes Fixate 1 dr Eulerius (1 oz Alkahest): Bius Fixate 1 dr Periphius (1 oz Alkahest): Cius Fuse 1 dr Bius, 1 dr Bius, 1 dr Cius, 1 dr Cius (4 oz Alkahest): Zius Fuse 1 dr Zius, 1 dr Bius (2 oz Alkahest): Hium Fuse 1 dr Cius, 1 dr Periphius, 1 dr Periphius (3 oz Alkahest): Dius Project 1 oz Hium, 1 oz Dius (3 oz Alkahest): Eium Fuse 1 dr Zius, 1 dr Cius (2 oz Alkahest): Lium Project 1 oz Lium, 1 dr Cius (3 oz Alkahest): Oium Fuse 1 dr Bius, 1 dr Cius, 1 dr Eulerius, 1 dr Eulerius (4 oz Alkahest): Cium Ferment 1 dr Zius, 1 dr Periphius (2 oz Alkahest): Sium Project 1 dr Cium, 1 dr Cium (4 oz Alkahest): Wium Ferment 1 dr Wium, 1 dr Aquaphidium (4 oz Alkahest): Wium Project 1 dr Oium, 1 dr Cius (3 oz Alkahest): Rium Ferment 1 dr Eium, 1 dr Aquasoothius (3 oz Alkahest): Dium Project 1 dr Sium, 1 dr Aquasoothius (3 oz Alkahest): Xium Multiply 1 oz Hium, 1 oz Eium, 1 oz Lium, 1 oz Lium, 1 oz Oium, 1 oz Cium, 1 oz Sium, 1 oz Wium, 1 oz Oium, 1 oz Rium, 1 oz Lium, 1 oz Dium, 1 oz Xium (26 oz Alkahest): Scribius This is one weird language. The above is probably not entirely optimal, but I also don't think that the optimal solution will be significantly shorter (I did try to obtain the numbers as efficiently as possible locally). Also, the language spec seems to imply that the amounts of the reagents should actually match up (when multiplied by their "substance numbers" which are the sums of their ASCII values...), but the only interpreter I could find doesn't seem to be checking that. In fact, the interpreter had a memory corruption bug which I had to fix to run the above code. Some explanation would probably be helpful. Let e, π, and φ have their usual meanings. Then the above code translates roughly to the following pseudocode: b = floor(e) // 2 c = floor(π) // 3 z = b * b * c * c // 36 H = z * b // 72 d = c * π * π // 29.6088 E = H + d // 101.6088 L = z * c // 108 O = L + c // 111 C = 2 * 3 * e * e // 44.3343 S = z - π // 32.8584 W = C + C // 88.6686 W = W - φ // 87.0506 R = O + c // 114 D = E - 1 // 100 X = S + 1 // 33 Print( H, E, L, L, O, C, S, W, O, R, L, D, X ) 13 # BBC BASIC, 20 bytes PRINT"Hello, World!" Ahh, this was my first language :) so BBC Basic does not accept ? as a shorhand for print? – edc65 – 2015-08-28T14:27:16.900 @edc65 I have no idea... I'll try – Beta Decay – 2015-08-28T14:28:23.747 @edc65 It doesn't work in BBC BASIC for Windows – Beta Decay – 2015-08-28T14:53:48.370 Strange, as it's quite standard in basic. A posted an answer as VBA – edc65 – 2015-08-28T14:59:24.360 Is the trailing quotation mark required? – 12Me21 – 2017-02-01T20:58:50.543 1@edc65, The "?" is NOT accepted, seems it conflicts with BBC Basic's PEEK() variant. But this is: P."Hello, World!" – user3710044 – 2017-03-19T08:31:35.970 13 # Packed 7-bit ASCII, 12 fÍëWßËfD Since Markdown eats some of the characters, here's a hexdump:$ xxd hello.ascii
0000000: 9197 66cd eb10 57df cb66 4420            ..f...W..fD

And yes, the trailing space is necessary.

Packed 7-bit ASCII is created by taking 8-bit ASCII (the normal kind), removing the high zero bit from each byte, packing the remainder, and then padding it out with trailing zero bits.

According to this site, this character encoding is used by "a specific US MIL STD message header format", making it a real thing.

2Is Packed ASCII a programming language on its own right? – user3819867 – 2015-08-30T16:04:01.850

@user3819867 It's an edge case. It depends on definitions. – isaacg – 2015-08-30T16:19:26.127

Packed 7-bit ASCII is the encoding SMS uses – slebetman – 2015-09-01T04:31:58.700

13

# Cubix, 31 29 bytes

Saved 2 bytes thanks to @MartinBüttner

./v.o;@?/"!dlroW"S',u/"Hello"

I proudly present Cubix, my new 2-dimensional, stack-based esolang. Cubix is different from other 2D langs in that the source code is wrapped around the outside of a cube.

Test it online! You can now adjust the iteration speed if you want it to run faster or slower.

## Explanation

The first thing the interpreter does is figure out the smallest cube that the code will fit onto. In this case, the edge-length is 3. Then the code is padded with no-ops . until all six sides are filled. Whitespace is removed before processing, so this code is identical to the above:

. / v
. o ;
@ ? /
" ! d l r o W " S ' , u
/ " H e l l o " . . . .
. . . . . . . . . . . .
. . .
. . .
. . .

Now the code is run. The IP (instruction pointer) starts out on the top left char of the far left face, pointing east. Here's an overview of the basic commands:

• \|/_ are mirrors, and reflect the IP depending on the direction it's traveling.
• >v<^ set the direction of the IP unconditionally.
• ? turns the IP right if the top item is positive, or left if it's negative.
• ' pushes the char code of the next char.
• " toggles string mode, performing ' on each char until the IP encounters another ".
• o outputs a char code.
• ; pops an item.
• @ ends the program.

The first char we encounter is ", which toggles string mode. Each char code is pushed to the stack until we run into the next ". Then we push a space with S, and a comma with ',. The stack now contains !dlroW ,.

Next we hit u, which turns the IP right, then right again before executing the next instruction. The IP is now at the far right of the fifth row in the above diagram, facing west. Now the IP executes "olleH", making the stack !dlroW ,olleH. The / points the IP south, where it travels through the bottom row of the bottom face, back up to the S (which adds an extra space), and finally hits the v.

Now the IP is in what I call the "output loop". First it moves down and hits the ;, which turns pops the unnecessary space. Then it hits the ?, which directs it through o to output, bounces back around to ; to pop the char, then comes back to ?.

This repeats until the stack is empty. Then, since the top of the stack is no longer truthy, ? leaves the IP headed north. The next char is @, which terminates the program.

I'm not sure if this program is optimal; there's four two no-ops which could probably be put to better use. Martin and I will keep looking to find a better solution.

12

# Z80Golf, 19 bytes

00000000: 674a 4343 4003 0f78 405d 434b 0e76 7e23  gJCC@..x@]CK.v~#
00000010: e5ee 2f                                  ../

Try it online!

Z80Golf is, essentially, a Z80 machine hooked up to $8000=putchar and$8003=getchar. The source code is a binary copied to $0000 (all other memory is zeroed out, just like the registers); execution starts there and runs until a halt instruction. It was designed by mokehehe on anarchy golf for code golf competitions there, but seems to have fallen into disuse. It's really fun to golf in, but excelling in it requires a pretty thorough understanding of the Z80 chip (that I myself don't even have, but some golfers like kodera and *yuko* do, and every solution they write is very clever.) A naïve Hello, World! program might look like this: start: ld a, (ix+hello) or a jr nz, okay halt okay: call$8000  ; putchar
inc ix
jr start
hello:
db "Hello, World!"

It assembles into a 27 byte binary. It even cheats a little bit: we don't need to explicitly zero-terminate the string "Hello, World!" ourselves, as all the memory past our source code is zeroed already. And it's still a fair bit longer than our 19-byte solution.

So how does the 19-byte solution work?

It doesn't look much like a Hello, World! program when disassembled:

ld h,a
ld c,d
ld b,e
ld b,e
ld b,b
inc bc
rrca
ld a,b
ld b,b
ld e,l
ld b,e
ld c,e
ld c,0x76
ld a,(hl)
inc hl
push hl
xor 0x2f

We can look at the program in a slightly more revealing manner.

db 47 ^ 'H'  ; 67  ld h, a
db 47 ^ 'e'  ; 4a  ld c, d
db 47 ^ 'l'  ; 43  ld b, e
db 47 ^ 'l'  ; 43  ld b, e
db 47 ^ 'o'  ; 40  ld b, b
db 47 ^ ','  ; 03  inc bc
db 47 ^ ' '  ; 0f  rrca
db 47 ^ 'W'  ; 78  ld a, b
db 47 ^ 'o'  ; 40  ld b, b
db 47 ^ 'r'  ; 5d  ld e, l
db 47 ^ 'l'  ; 43  ld b, e
db 47 ^ 'd'  ; 4b  ld c, e
db 47 ^ '!'  ; 0e  ld c,
halt         ; 76        $76 ld a, (hl) inc hl push hl xor 47 ; 32749 nop instructions, and then: ; putchar(A) ; ret Whenever the PC becomes$8000, Z80Golf is programmed to write the byte in register A to STDOUT, and then effectively execute a ret (the PC is set to (SP) and SP is incremented by 2). In our code, instead of using call $8000 to access this behavior, we let the PC wade through a sea of nops (opcode 00) from$0013 to $7fff. Keeping this in mind, the code will run as follows: • Execute some meaningless instructions (effectively NOPs), starting from ld h,a. • Set A to mem[0] ^ 47, which is 'H'. • Increment HL and push it ($0001).
• Fall through to putchar, and return to the $0001 we pushed. • Execute some meaningless instructions, starting from ld c,d this time. • Set A to mem[1] ^ 47, which is 'e'. • Increment HL and push it ($0002).
• Fall through to putchar, and return to the $0002 we pushed. • Set A to mem[12] ^ 47, which is '!'. • Fall through to putchar, and return to the$000d we pushed.
• We finally jump into the argument of the ld c, $76 — and$76 is the halt opcode!

Of course, the constant 47 was carefully picked so that none of the first instructions 13 influence the execution of the code, and the last one is some opcode that takes a single-byte argument, “hiding” the halt opcode until we jump there after printing '!'.

12

# C#, 85 67 bytes

class P{static void Main(){System.Console.Write("Hello, World!");}}

I guess it cannot get worse. Did not even beat Java this time.

7class P{static void Main(){System.Console.WriteLine("Hello, World!");}} -- 71 bytes. More golfing you must do young padawan. – Stephan Schinkel – 2015-08-28T13:36:14.593

7You don't need to specify the accessibility modifiers, C# will use defaults so you can remove both instances of public. You can also use the Write method on Console to save a few more bytes. – None – 2015-08-28T13:36:55.520

4The newline in the output is optional, so use Write instead of WriteLine to save 4 bytes – SLuck49 – 2015-08-28T15:49:59.857

Yeah, a lang of Microsoft is worse than Java! – univalence – 2016-07-18T18:23:06.773

12

# Fission, 17 bytes

R"Hello, World!";

or

;"!dlroW, olleH"L

or any cyclic permutation of the two. In Fission, we need the R or L to release an atom and get control flow going. " toggles print mode, which just prints everything encountered until switched off. Finally ; destroys the atom to avoid an infinite loop.

12

# Sed, 14 bytes

I'm hoping the sed exemption from no-input-rules applies here. If so, we can do:

cHello, World!

All that is required as input is one empty line.

cHello, World! – Mitch Schwartz – 2015-08-28T18:28:49.553

1@MitchSchwartz excellent - I've never used the c sed command before - thanks! – Digital Trauma – 2015-08-28T18:56:06.080

Something like sed -e 'cHello, World!' <<<'' – F. Hauri – 2018-12-09T13:41:29.060

12

# gs2, 2 bytes

\x12h

where \x12 is a raw byte.

11

# Lost, 5754 45 bytes

Two bytes saved thanks to @MartinEnder

v<<<<<<<<<<>>>>>>>>>>>
>%?"Hello, WorldvU"-+@

Try it online!

## Explanation

Lost is a 2 dimensional language in which the start location and direction are entirely random. As you might imagine it is rather difficult to write deterministic programs in lost. However the language has a couple of design features that allow for deterministic programs to be written.

Here's how this one works:

I'll first give you some information on the operations in Lost that are important here, so you don't have to read the github. I will leave out the more obvious ones.

• @ exits, but only if the "safety" is off. The safety begins on.

• % turns the safety off.

• ? Pops the TOS and jumps if it is non-zero.

• ! jumps unconditionally.

• ( pops a value and saves it for later.

Ok now we are read to dive in.

The main code is the following line

"Hello, WorldvU"-+@

This pushes the string Hello, WorldvU, subtracts the U from the v to get a !, and then terminates the program (we assume the safety is off)

However we have to get to this program so we create a line of arrows to catch the randomly moving pointers

v<<<<<<<<<<<<<<<<<<<<
>%"Hello, WorldvU"-+@

We also add a % to turn the safety off once we have corralled the programs. We can now see that the v is in the string to redirect ips that start inside the string.

Our last problem is that we sometimes accumulate garbage we don't want in our final product before we arrive at the start of execution. To fix this we just eat everything on the stack that is not zero (this only works because the garbage never contains a zero).

v<<<<<<<<<<<<<<<<<<<<<<<
>%?!<"Hello, WorldvU"-+@

The code >&?!< acts our loop, discarding values until it discards a zero.

This doesn't work because the ! can jump to itself over the top or bottom of the program when the ip starts on it moving either up or down. This will cause an infinite loop (this is the same reason we didn't include ! in the original Hello, world! string). We can fix two ways. The first way, which works in most scenarios, is to another stream below to catch this specific pointer.

v<<<<<<<<<<<<<<<<<<<<<<<
>%?!<"Hello, WorldvU"-+@
^<<<

With this new stream our program has now covered all the possibilities and is deterministic.

However if we want to be a bit more clever and save a few bytes we can do away with ! entirely. We replace our loop with <%?.

v<<<<<<<<<<<<<<<<<<<<<
>%?"Hello, WorldvU"-+@

Since there is a v later on the line which sends us back to the beginning of the loop our ? will reset the loop if the top of the stack is non-zero, while if it is zero it will hit " and complete the program as intended.

Lastly I reversed some of the upper stream. This just makes the program a little faster, doesn't lose me any bytes so why not.

11

# VSL, 35 33 bytes

Saved 2 bytes thanks to @ASCII-Only

fn main(){print("Hello, World!")}

Try it online!

Okay after over one year development, the day has come where I can post this :D

There is a print("Hello, World!") function but this is shorter. As I seperate libc and libvsl this will probably have to switch over to print but for now this is the shortest.

Using fn can save two bytes – ASCII-only – 2018-04-11T03:16:57.377

11

# PDP-11 (Unix) Assembly, 33 38 bytes

Source (No trailing newline required):

sys 4;10;15;sys 1;<Hello, World!>

Binary output:

0000000 000407 000026 000000 000000 000000 000000 000000 000000
0000020 104404 000010 000015 104401 062510 066154 026157 053440
0000040 071157 062154 000041 000000 000000 000000 000000 000000
0000060 000000 000000 000000 000000 000000 000000
0000074

The output is zero-padded to 60 bytes for some reason, but I know enough about the architecture to know that it doesn't matter and can be considered 38 (maybe 37) bytes. Unfortunately, while this works on the terminal, it actually prints to STDIN.

So, a correct program (I believe it exits with status 1, but that's not important) is:

5200;sys 4;12;15;sys 1;<Hello, World!>

That 5200 in the beginning is actually an "inc r0" instruction, but writing it in octal is shorter. Coincidentally, the length of this source code is also 38 bytes.

0000000 000407 000030 000000 000000 000000 000000 000000 000000
0000020 005200 104404 000012 000015 104401 062510 066154 026157
0000040 053440 071157 062154 000041 000000 000000 000000 000000

Output clocks in at 20 non-zero words, or 39 non-zero bytes, and this time the assembler doesn't insert quite as much padding so the actual output file size is 48 bytes.

Unobfuscated source for the same program:

inc r0
sys write; 0f; 13.
sys exit
0: <Hello, World!>

If you actually assemble this source the output has an extra nonzero byte (value 2) in the second-last word of the output, probably something to do with the fact that named symbols were used for the system calls.

So is your answer optimized for short machine code, or for short source? Or both? Maybe post two header lines, one for the machine-code count and one for the asm source count? – Peter Cordes – 2018-04-13T00:52:48.507

11

# GNU Make, 27

$(info Hello, World!) a:;@: You can stick these two lines together, in either order, on one line to eliminate one more char. – user3710044 – 2017-03-19T08:48:45.123 11 # Carrot (version: ^3), 13 bytes Carrot is a language of Κριτικσι Λίθος. The syntax is stack^commands, where the stack is a string, and the interpreter outputs everything that's on the stack at the end of the program. The carrot is optional if you have no commands. Hello, World! In version ^, the carrot wasn't optional yet if you had no commands, so then it was 14 bytes: Hello, World!^ 1 – Addison Crump – 2015-11-01T18:11:45.513 Write the version number as "^". – user41805 – 2015-11-02T05:51:55.293 @ΚριτικσιΛίθος Sure! Done. – ProgramFOX – 2015-11-02T06:40:33.547 Version ^3 makes the ^ optional is you do not want to use any commands. Thus this can be shortened down by one byte. – user41805 – 2015-11-03T08:40:52.137 @ΚριτικσιΛίθος Cool! Added that. – ProgramFOX – 2015-11-03T08:43:58.303 10 # Hexagony, 30 29 bytes H;_e;r;2l.;P.QW;l/P1;@;0d;\o; Try it online! Source laid out: H ; _ e ; r ; 2 l . ; P . Q W ; l / P 1 ; @ ; 0 d ; \ o ; . . . . . . . . One more byte off! Here's a crappy gif of the program in action. Given there's 2 nops inside the program itself, I'm confidant this can be golfed by at least one more byte. I'm willing to offer a bounty for a smaller version. ### Old version: H;e;r;0Pld;P_1;l;;o;Q\;W\;$2@\

Try it online!

Source laid out:

H ; e ;
r ; 0 P l
d ; P _ 1 ;
l ; ; o ; Q \
; W \ ; $2 @ \ . . . . . . . Reuses the same tricks as Martin Ender's answer, i.e Q2 printed is the comma, P0 is the space, P1 is the bang, but manages to be 2 bytes shorter through clever mirroring to reuse several ;s and the o. ### Explanation: Here's a coloured Hexagony grid to show the non-branching path that the pointer takes: The executing code, ignoring mirrors, is: H;e;l;;o;Q2;P0;W;d$;o;$2r;0Pl;Wd;P1;@ Filtering out the skipped instructions and the literals that are overwritten by other literals, we are left with: H;e;l;;o;Q2;P0;W;o;r;l;d;P1;@ Which simply prints "Hello, World!" After a few attempts, I gave up on a size 3 Hexagony answer. You need a minimum of 12 instructions out of 19 reserved for string literals, along with three ;s for printing and one @ for ending the program. This leaves only 3 spaces for IP management and memory management, provided you find the optimal path that reuses both the o and the l. From all this, I'll rule that a size 3 answer is impossible, though I'll give a sizable bounty to anyone who proves me wrong. 1I posted a shorter solution. – user202729 – 2018-05-19T13:55:07.900 1I came up with a 25-byte solution by hand - this will be my first answer here! I'm a bit miffed now to find this has already been beaten, albeit by brute force. Up until half an hour ago i thought Martin's original post was the only one for Hexagony. Still, my approach is different from the others. Hope to post soon although it may have to wait till Saturday when I get back from vacation and have access to my computer again. – Oliphaunt - reinstate Monica – 2018-08-22T20:29:49.510 @Oliphaunt It's been a while, but I noticed you never posted your 25 byte solution. Do you still have it or remember it? – Jo King – 2019-09-26T02:51:40.670 10 # Javascript, 22 bytes alert("Hello, World!") You don't NEED semicolons in Javascipt! Don't you need them? – OldBunny2800 – 2016-04-14T21:19:56.100 Apparently not for 1 liners (I don't know JS golfably) – Blue – 2016-04-14T21:21:13.723 1The JS interpreter will automatically insert them where it thinks they should be, if they aren't present – MayorMonty – 2016-05-08T22:54:53.037 It does not print to stdout like the spec says – Valentin Lorentz – 2016-06-01T19:45:48.830 2 @ValentinLorentz Javascript doesn't have a stdout - I used the nearest alternate; see Default for Code Golf: Input/Output methods – Blue – 2016-06-01T19:48:38.383 10 # Foo, 14 bytes "Hello, World! Not printing Hello World seems to be a lot harder in Foo that the opposite... Try it online! Would s print Hello World? ;) – OldBunny2800 – 2016-04-14T21:18:43.647 Probably. – Dennis – 2016-04-14T21:20:14.167 If you find out, you might be able to golf it down to 0 or 1 byte! – OldBunny2800 – 2016-04-14T21:22:13.757 10 # Labyrinth, 4645 40 bytes 72.10:1.:8:..:):1:.#2#4..:1..4.:8.0.33.@ Try it online! Labyrinth is my new two-dimensional programming language (although the 2D'ness isn't really used here). Labyrinth operates on two stacks (although this code only uses one). Each character is a separate command. However, as opposed to most similar languages individual digits don't push that digit (which makes it annoying to build up larger numbers), instead they multiply the top of the stack by 10 before adding themselves. This allows you simply to write out the numbers you want to push. (Another language with this concept is Emmental.) The other commands you need to know for the above code are . which prints the top of the stack (modulo 256), : which duplicates the top of the stack, ) which increments it and # which pushes the current stack depth. @ terminates the program. There's only one tricky part: W is printed by appending a 1 to 111 (o), because 1111 % 256 = 87. Here is what the stack and output look like throughout the program: Command(s) Stack Output 72 [72] >< . >H< 10 [10] >H< : [10 10] >H< 1 [10 101] >H< . [10] >He< : [10 10] >He< 8 [10 108] >He< : [10 108 108] >He< .. [10] >Hell< : [10 10] >Hell< ) [10 11] >Hell< : [10 11 11] >Hell< 1 [10 11 111] >Hell< : [10 11 111 111] >Hell< . [10 11 111] >Hello< # [10 11 111 3] >Hello< 2 [10 11 111 32] >Hello< # [10 11 111 32 4] >Hello< 4 [10 11 111 32 44] >Hello< .. [10 11 111] >Hello, < : [10 11 111 111] >Hello, < 1 [10 11 111 1111] >Hello, < .. [10 11] >Hello, Wo< 4 [10 114] >Hello, Wo< . [10] >Hello, Wor< : [10 10] >Hello, Wor< 8 [10 108] >Hello, Wor< . [10] >Hello, Worl< 0 [100] >Hello, Worl< . [] >Hello, World< 33 [33] >Hello, World< . [] >Hello, World!< @ 1This maybe could be golfed more if you allow the code to intersect itself. – TheNumberOne – 2015-08-29T14:24:28.847 I really don't understand why "1111" is a "W". The ascii code for 'W' is 87. Can somebody explain this to me? – Robert Hickman – 2017-05-25T15:29:21.060 Oh, I see the explanation in the description, but I wasn't aware that . did a % 256 before printing. – Robert Hickman – 2017-05-25T15:41:42.800 10 # LLVM IR 4.0.1, 149145 152 bytes declare i8@puts(i8*)@t=global[14 x i8]c"Hello, World!\00"define void@main(){call i8(i8*)@puts(i8*getelementptr([14 x i8],[14 x i8]*@t,i1 0,i1 0))ret void} I'm not very good in LLVM IR, so chances are good, that it's possible with fewer bytes. Ungolfed Version: declare i8 @puts(i8*) ; Declare puts from C standard. i8, was the shortest return type possible. @t=global [14 x i8] c"Hello, World!\00" ; Hello world string as global, to have a pointer to it. define void @main(){ call i8(i8*) @puts(i8* getelementptr([14 x i8], [14 x i8] *@t, i1 0, i1 0)) ; Get pointer to constant "Hello, World!" and pass it to puts ret void } would int main be smaller, with ret 0 instead of ret void? I don't know LLVM IR at all, really >.< – Peter Cordes – 2018-04-13T00:54:05.340 You can put a raw null byte instead of \00, do call i8@puts, and use [14x i8] to save space – EasyasPi – 2020-12-30T20:39:44.847 10 # Mouse, 19 bytes "Hello, World"33!'$

Oddly enough, ! inside of a string makes a newline, so we have to work around that by getting the ASCII code for !, which is 33, and outputting that as a character.

10

# Ziim, 1222 bytes

In an unexpected turn of events, I'm counting this submission in UTF-16.

↘ ↓↘↘↘↘↙↓↘↘ ↙↓↘ ↓↘ ↙↘←↓ ↘↘↙↓↘↘↘↙↓↘↘↘↘↙↓↘↘↘↘↙↓ ↘↘↙↓↘↘↙↓↘ ↙ ↘ ↓↘ ↙↘←↓↘ ↙ ↘ ↓ ↘↘↙↓↘↘↙↓↘↘↘↘↙↓ ↘ ↙↘←↓↘ ↙ ↘ ↓ ↘ ↙ ↘ ↓↘↘↙↓↘↘↘↙↓↘↘↘↙↓↘↘ ↙↓↘←↓↘ ↙↓↘ ↓↘↘↙↓ ↘↘↙↓↘↘↙↓↘ ↙↘←↓↘ ↙↘←↓ ↘ ↙↘←↓ ↘↘↙↓↘↘↙↓ ↘ ↙ ↘ ↓↘↘ ↙ ↘ ↓↘ ↙↓↘←
↓→↘ ↑↑↓→↘ ↑↓  ↓→↘ ↓↓↓→↘↘ ↓→↘ ↑↓→↘ ↑↑↓→↘ ↑↑↓→↘↘ ↓→↘ ↓→↘ ↓↓↓↓→↘ ↓↓↓→↘ ↓↓↓↓→↘↘ ↓→↘ ↓→↘ ↑↑↓→↘↘ ↓↓↓→↘ ↓↓↓↓→↘↘ ↓↓↓↓→↘ ↓→↘ ↑↓→↘ ↑↓→↘ ↑↓  ↓→↘ ↓  ↓→↘ ↓→↘↘ ↓→↘ ↓→↘ ↓↓↓→↘ ↓↓↓→↘↘ ↓↓↓→↘↘ ↓→↘ ↓→↘↘ ↓↓↓↓→↘ ↑↓↓↓↓→↘ ↓  ↓→
↗  ↑↖ ↗  ↑↖↗↑↗↗  ↑↗↗↗  ↑↑↗  ↑↖↗  ↑↖ ↗  ↑↖ ↗  ↑↑↗  ↑↗  ↑↗↗↗↗  ↑↗↗↗  ↑↗↗↗↗  ↑↑↗  ↑↗  ↑↖ ↗  ↑↑↗↗↗  ↑↗↗↗↗  ↑↑↗↗↗↗  ↑↗  ↑↖↗  ↑ ↗  ↑↖↗↑↗↗  ↑↗↑↗↗  ↑↗  ↑↑↗  ↑↗  ↑↗↗↗  ↑↗↗↗  ↑↑↗↗↗  ↑↑↗  ↑↗  ↑↑↗↗↗↗  ↑↖↗↗↗↗  ↑↗↑↗↗

Because the code snippet above will likely not render in a very readable manner for you (either because of missing characters, or because the diagonal arrows aren't as monospaced as they should be), here is an image of the solution. I've marked the concatenators where a new byte starts in red:

Click for larger version

Well, this is a bit embarrassing. I spent quite some time on this solution, and at 610 characters, it is 267 characters shorter than the one on the esolangs page. However, it contains a lot more arrows, and because those are 3 bytes in UTF-8, it's actually longer than the one on esolangs (1516 vs 1345). But because this solution is so dense and contains far more arrows than spaces, I'm actually saving bytes by using UTF-16 and counting each character as two bytes.

Anyway, regardless of how we're counting, this is far from optimal. The above code is entirely linear, and builds one bit at a time. So I'm not reusing any bitstrings (like I could for the ls or os or even other substrings). I chose this approach because I wanted to start with something where it would be easier to pack the arrows very densely. If one used a more square layout, one could make use of a lot more repetition in the output (on a bit level), and thereby make massive savings.

Most 2d languages are generally scored by the area of the bounding box, why not do that here? – SuperJedi224 – 2016-01-29T17:31:08.870

@SuperJedi224 [citation-needed]? I've never scored any 2D language like that and the only one which I've seen like that is Piet where I think that's not how we should do it. – Martin Ender – 2016-01-29T17:40:28.587

I've definitely seen befunge and <>< scored that way before, and that's how I've generally been scoring BotEngine. – SuperJedi224 – 2016-01-29T17:56:18.387

2@SuperJedi224 if I saw that I would recommend changing it. Programs should be scored by the size of the source file and I don't know any 2D language that chokes on omitted trailing spaces. Plus, if a submission did use up the entire bounding box, you wouldn't be counting any bytes for the aspect ratio of the grid, which is also important information. – Martin Ender – 2016-01-29T18:11:03.717

10

# Pancake Stack, 1118 1073 bytes

Put this supercalifragilisticexpialidociouseventhoughthesoundofitissomethingquite pancake on top!
Show me a pancake!
Put this floccinaucinihilipilification pancake on top!
Put the top pancakes together!
Show me a pancake!
Put another pancake on top!
Put this piquant pancake on top!
Put the top pancakes together!
Show me a pancake!
Show me a pancake!
Put another pancake on top!
Put this big pancake on top!
Put the top pancakes together!
Show me a pancake!
Put this osteosarchaematosplanchnochondroneuromuelous pancake on top!
Show me a pancake!
Put this kolmivaihdekilowattituntimittari pancake on top!
Show me a pancake!
Put the top pancakes together!
Put this scrumptious pancake on top!
Put the top pancakes together!
Show me a pancake!
Eat the pancake on top!
Show me a pancake!
Put this big pancake on top!
Put the top pancakes together!
Show me a pancake!
Eat the pancake on top!
Show me a pancake!
Eat the pancake on top!
Take off the syrup!
Show me a pancake!
Put this nonilfenossipolietilenossietonolo pancake on top!
Show me a pancake!
Eat all of the pancakes!

I've been avoiding this one because I haven't found a good way of golfing it yet, but here's a submission for now.

The relevant operations are:

Instruction                               Result
--------------------------------------------------------------------------
Put this X pancake on top!                Push word length of X to stack
Eat the pancake on top!                   Pop and discard
Put the top pancakes together!            Add top two
Put another pancake on top!               Duplicate
Show me a pancake!                        Print as ASCII without popping
Take off the syrup!                       Decrement all stack values by 1
Eat all of the pancakes!                  Terminate program

If you take a look a Pancake Stack's full instruction set, you'll notice that you only ever have access to the top two stack elements at any time, which makes this language a pain to program in normally. That and the fact that you can only output as ASCII, i.e. no numeric output.

Note that, if you're using the Python interpreter, you'll need an extra line with a ~ afterwards if you want to test by piping in a file. We don't use it here, but anything after the ~ is treated as normal STDIN input.

10

# ELF 32-bit LSB executable (Linux), 59 bytes

0000000: 7f 45 4c 46 01 00 00 00 00 00 00 00 00 90 43 0d  .ELF..........C.
0000010: 02 00 03 00 19 90 43 0d 19 90 43 0d 04 00 00 00  ......C...C.....
0000020: b9 2e 90 43 0d b2 0d cd 80 cc 20 00 01 00 48 65  ...C...... ...He
0000030: 6c 6c 6f 2c 20 57 6f 72 6c 64 21                 llo, World!

This exits with INT 3 (breakpoint), so your shell may display a message to indicate this. However, the program itself prints nothing to STDERR.

Try it online!

### Verification

$cksum hw32 3205536342 59 hw32$ ./hw32
Hello, World!Trace/breakpoint trap
$./hw32 | cat; echo Hello, World!$ ./hw32 | xxd -g 1
0000000: 48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21           Hello, World!

or echo $(./hw32) – F. Hauri – 2018-12-09T13:53:14.400 9 # USML, 9 bytes S0h7cWs8h Try it online! ## Explanation: S0h7cWs8h S0h7 # Get characters 0-7 of h ("Hello, world!"). cW # Get the character "W" s8h # Get the remaining characters, starting at character 8, of h. This program is an interesting problem, as it has a command that outputs "Hello, world!" (and an empty program will also do this), but the capitalization is not correct. As a result, we need to take some substrings and add in the correct character. 7This is probably the first interesting use of a HW-built-in I've seen in this challenge. – Martin Ender – 2017-04-08T22:15:26.187 9 # R, 20 bytes cat("Hello, World!") 9 # INTERCAL, 285 bytes DO,1<-#14 DO,1SUB#1<-#238 DO,1SUB#2<-#108 DO,1SUB#3<-#112 PLEASE DO,1SUB#4<-#256 DO,1SUB#5<-#64 DO,1SUB#6<-#194 PLEASE DO,1SUB#7<-#48 DO,1SUB#8<-#26 DO,1SUB#9<-#244 PLEASE DO,1SUB#10<-#168 DO,1SUB#11<-#24 DO,1SUB#12<-#16 PLEASE DO,1SUB#13<-#162 DO,1SUB#14<-#52 DO READ OUT,1 DO GIVE UP Try it online! 9 # Prelude, 38 bytes 92480969393782833909095806(^+^+^^+++!) If you're using the Python interpreter, you'll need to make sure that NUMERIC_OUTPUT is set to False. Prelude is a relatively simple stack-based language, with 0-9 pushing the corresponding single digits and the only arithmetic being addition and subtraction. In particular, there is no multiplication. To make the most of the single digit pushing behaviour, I took a look at the code points in various bases. For base 12, we get this: [[6 0] [8 5] [9 0] [9 0] [9 3] [3 8] [2 8] [7 3] [9 3] [9 6] [9 0] [8 4] [2 9]] Everything here is a single digit - that's perfect! This means that we can encode each character using two digits via base 12, e.g. H -> 72 (base 10) -> 60 (base 12). That's what the long string of 26 digits at the beginning is for. The back half of the code then needs to take each pair of digits a, b and give 12*a+b. But remember, Prelude doesn't have multiplication! What it does have, however, is ^ and v, which get the top stack values from the program rows ("voices") above and below. Since this is a one-line program, ^ effectively duplicates the top of the stack, allowing us to do ^+^+^^++ to multiply the top stack element by 12. We then add the second digit with + and output with !. All of this is wrapped in (), which is a BF-like loop which executes while the top stack element is nonzero. 9 # ???, 96 bytes ,;;..;...;.;,,,,;,,"......";...........-,'",-.";;,,,,!;...!;,!!...!;;;!-!-!-!...!,,,,,,!-,!;;;.! Based on the 95-byte approach by Mitch Schwartz. Note that the 92-byte Brainfuck solution would yield 97 bytes in ???, because the sequential loops require four more apostrophes. 24This is... wait, wrong challenge. – Dennis – 2015-08-29T04:38:34.763 80 bytes – ASCII-only – 2018-04-12T05:24:13.657 9 # Emotinomicon, 18 characters / 30 bytes Try it here. !dlroW ,olleH⏪⏬⏩ Explanation: !dlroW ,olleH ⏪ ⏬ ⏩ explanation begin quote string !dlroW ,olleH end quote string ⏪ open loop ⏬ pops and outputs top of stack as character ⏩ close loop 9 # ELF 64-bit LSB executable (Linux), 104 bytes 0000000: 7f 45 4c 46 02 01 01 03 b0 04 b3 01 b2 0e eb 18 .ELF............ 0000010: 02 00 3e 00 01 00 00 00 08 00 40 00 00 00 00 00 ..>.......@..... 0000020: 30 00 00 00 00 00 00 00 b9 48 00 40 00 90 eb 30 0........H.@...0 0000030: 01 00 00 00 01 00 38 00 01 00 00 00 00 00 00 00 ......8......... 0000040: 01 00 40 00 00 00 00 00 48 65 6c 6c 6f 2c 20 57 ..@.....Hello, W 0000050: 6f 72 6c 64 21 0a 00 00 6f 72 6c 64 21 0a 00 00 orld!...orld!... 0000060: cd 80 b0 01 b3 00 cd 80 ........ This sets as many proper headers as possible without affecting the byte count, prints a trailing linefeed and exits cleanly with exit code 0. Try it online! ### Verification$ cksum hw64
3288151474 104 hw64
$file hw64 hw64: ELF 64-bit LSB executable, x86-64, version 1, statically linked, corrupted section header size$ ./hw64
Hello, World!
$echo$?
0

Disassembly output of the code stuffed into the ELF headers would be nice, if you needed any special tricks to make instruction bytes also be valid ELF headers. (Future readers: see http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html for more about this kind of hack.)

– Peter Cordes – 2018-04-13T00:57:46.783

O_o why is there an extra orld! – ASCII-only – 2018-04-13T04:55:29.047

@ASCII-only The answer saves bytes by storing data in the ELF's program header. The longs at 0x50 and 0x58 encode the virtual and physical addresses of the segment, and they program segfaults if they do not match. – Dennis – 2018-04-13T05:26:53.423

8

# Monkeys, 484460455 448 bytes

7 RIGHT
7 RIGHT
7 RIGHT
7 RIGHT
7 UP
5 DOWN
5 RIGHT
4 DOWN
7 TEACH
7 BOND
4 UP
7 BOND
7 TEACH
7 TEACH
6 YELL
4 TEACH
4 TEACH
7 FIGHT
5 TEACH
6 YELL
7 TEACH
7 TEACH
5 FIGHT
6 YELL
6 YELL
7 TEACH
5 FIGHT
6 YELL
7 EGO
4 TEACH
5 TEACH
6 YELL
4 FIGHT
7 TEACH
6 YELL
4 TEACH
4 TEACH
4 DOWN
7 TEACH
4 UP
4 TEACH
5 FIGHT
6 YELL
4 TEACH
7 TEACH
6 YELL
7 TEACH
5 FIGHT
6 YELL
7 FIGHT
5 FIGHT
5 FIGHT
6 YELL
7 FIGHT
7 FIGHT
6 YELL
7 EGO
7 TEACH
7 TEACH
6 YELL

Try it online!

### How it works

Monkeys consists internally of a 10x10 grid containing 7 monkeys (and 14 bananas we won't use). The grid initially looks as follows.

..!1.!....
.......2!.
.........!
.3.!......
.......!..
.!....!...
..5.!4....
....6...!.
......!...
.7......!.

All monkeys initially have a value of 0. Moving a monkey UP, DOWN, LEFT, or RIGHT increments its value by 1, unless the target square is adjacent (horizontally, vertically, or diagonally) to another monkey.

In addition, any monkey can modify all adjacent monkeys' values with TEACH (adding the "teacher's" value to adjacent monkeys' values), FIGHT (subtracting), BOND (multiplying), and EGO (dividing).

First,

7 RIGHT
7 RIGHT
7 RIGHT
7 RIGHT
7 UP
5 DOWN
5 RIGHT

moves monkeys 5 and 7 to their final positions. This sets 5's value to 1 and 7's value to 4. The grid now looks as follows.

..!1.!....
.......2!.
.........!
.3.!......
.......!..
.!....!...
....!4....
...56...!.
.....7!...
.!......!.

Now,

4 DOWN
7 TEACH
7 BOND
4 UP

monkey 4 moves down (and is now adjacent to 7), monkey 7 adds its value (4) to monkeys 4 and 6, monkey 7 multiplies 4's and 6's values by 4, then 4 moves back to its place. The monkeys' values are now as follows.

5:  1
7:  4
4: 16

6: 16

From now on, we'll mostly use monkeys 5, 7, and 4 to add or subtract 1, 4, or 16 to/from monkey 6's value. Making monkey 6 YELL prints its value as a character.

If we represent monkey 6's value with v, the remainder of the program looks as follows in pseudo-code.

7 BOND   v *=  4 // v ==  64
7 TEACH  v +=  4 // v ==  68
7 TEACH  v +=  4 // v ==  72 == 'H'
6 YELL   putchar(v)
4 TEACH  v += 16 // v ==  88
4 TEACH  v += 16 // v == 104
7 FIGHT  v -=  4 // v == 100
5 TEACH  v +=  1 // v == 101 == 'e'
6 YELL   putchar(v)
7 TEACH  v +=  4 // v == 105
7 TEACH  v +=  4 // v == 109
5 FIGHT  v -=  1 // v == 108 == 'l'
6 YELL   putchar(v)
6 YELL   putchar(v)
7 TEACH  v +=  4 // v == 112
5 FIGHT  v -=  1 // v == 111 == 'o'
6 YELL   putchar(v)
7 EGO    v /=  4 // v ==  27
4 TEACH  v += 16 // v ==  43
5 TEACH  v +=  1 // v ==  44 == ','
6 YELL   putchar(v)
4 FIGHT  v -= 16 // v ==  28
7 TEACH  v +=  4 // v ==  32 == ' '
6 YELL   putchar(v)
4 TEACH  v += 16 // v ==  48
4 TEACH  v += 16 // v ==  64
4 DOWN   The next operation will affect monkey 4 as well.
7 TEACH  v +=  4 // v ==  68
4 UP     Monkey 4's value changed from 16 to 20.
4 TEACH  v += 20 // v ==  88
5 FIGHT  v -=  1 // v ==  87 == 'W'
6 YELL   putchar(v)
4 TEACH  v += 20 // v == 107
7 TEACH  v +=  4 // v == 111 == 'o'
6 YELL   putchar(v)
7 TEACH  v +=  4 // v == 115
5 FIGHT  v -=  1 // v == 114 == 'r'
6 YELL   putchar(v)
7 FIGHT  v -=  4 // v == 110
5 FIGHT  v -=  1 // v == 109
5 FIGHT  v -=  1 // v == 108
6 YELL   putchar(v)
7 FIGHT  v -=  4 // v == 104
7 FIGHT  v -=  4 // v == 100 == 'd'
6 YELL   putchar(v)
7 EGO    v /=  4 // v ==  25
7 TEACH  v +=  4 // v ==  29
7 TEACH  v +=  4 // v ==  33 == '!'
6 YELL   putchar(v)

8

# COBOL, 55 bytes

PROGRAM-ID.H.PROCEDURE DIVISION.DISPLAY"Hello, World!".

Thankfully not quite as verbose as some ancient bloated languages like Java.

2You're cheating. Last I checked, COBOL needed a lot of newlines and useless spaces at the start of each line... – Wouter Verhelst – 2015-12-15T11:05:05.357

When I compile that at http://www.tutorialspoint.comcompile_cobol_online.php it says Error: syntax error, unexpected "end of file", expecting "FUNCTION-ID" or "PROGRAM-ID" because it doesn't like the missing newlines. The exact same code on three lines compiles and runs.

– Jerry Jeremiah – 2016-03-17T23:34:27.210

1

@JerryJeremiah This works just fine with GNU COBOL, assuming you provide the -F (or -free) flag. https://tio.run/##S85Pys/RTc8r/f8/IMjfPcjRV9fTRc9DD8hxdnUJDXJVcPEM8wz29PfTc/EMDvBxjFTySM3JyddRCM8vyklRVNL7//9fclpOYnrxf103AA

– Dennis – 2017-07-17T20:45:53.770

8

if(j)invert()if(l)change()if(q)input()if(t)output(x);, 13 bytes

Hello, World!

Breaks the scoreboard. Any non-instruction characters are printed verbatim.

8

## Brian & Chuck, 4238 32 bytes

_#Jgnnq."Yqtnf#_{?
#{<{>-?>--.>?

Try it online!

Introducing my latest esolang, originally submitted for Create a programming language that only appears to be unusable.

Each of the two lines defines a Brainfuck-like program which operates on the other program's source code - the first program is called Brian and the second is called Chuck. That makes "Hello, World!" about as simple as it is in Self-modifying Brainfuck (compared to Brainfuck itself).

I said that looping was too expensive in B&C to be worthwhile for a simple "Hello, World!", but it turns out I was wrong. Now I'm much less convinced that the code is optimal as it stands...

### Explanation

One note about the source code: when parsing it, the interpreter replaces all _ with null bytes to make it easier to insert zero cells into the tapes.

Notice that Jgnnq."Yqtnf# is Hello, World! shifted by two characters. Why is it shifted? Because the , in Hello, World! is a valid command which would set a cell on Chuck to -1. We could shift it by one character (either way), but then the , would turn into either + or - which are also valid commands. We could reverse those at the end of Brian but the code as above has the same byte count and it seems a bit neater: we shift them by two characters, such that . becomes , which is a no-op for Brian.

So, when the program begins, Brian ignores everything on the tape until {? which switches control to Chuck, starting on the second command.

{<{> on Chuck finds the first non-zero cell on Brian (initially the #, which is just a dummy no-op). We decrement it with -. If that didn't make the cell zero yet, ? switches control back to Brian. Brian again ignores all the "code" in Jgnnq."Ypynf#_ and resets the loop on Chuck with {?.

Once that first cell has been zeroed, ? is a no-op. >--. moves to the next cell, subtracts 2 (to correct the offset) and prints it. Then we check if there's another character left to print by moving one to the right with >. If this reaches the null byte after the string (the _ on Brian's tape), then ? is a no-op and the program terminates. If that isn't a null byte yet, we've got more printing to do, and start over by switching to Brian who resets the loop with {? once more.

3Congratulations on posting the 300th answer to this question. [insert_celebrate_emoticon_here] – manatwork – 2015-11-06T14:31:04.570

8

## Monicelli, 46 bytes

Lei ha clacsonato
"Hello, World!" a posterdati

Probably appreciated only by italian coders, all the tokens of this language are taken from a well-known italian movie called "amici miei"

8

# 05AB1E, 14 7* bytes

*14 bytes for the use of the trademarked Ÿ

Code:

”Ÿ™,‚ï!

Try it online!

Like Jelly, this uses a compression method using an English dictionary. How it works? Let's find out:

”       # Start a compressed string with all words titlecased
Ÿ      # In Info.txt, you can see that this has index 24
™     # Index 19
# These two indexes combined is 2419, in the dictionary you can see that the
2419th word is hello
,    # Since this has no index, this will be interpreted as a normal character
‚ï  # Index 0118, which is the word "world". An extra space before this word is
! # Regular exclamation mark
# All the compressed words are automatically title cased.
resulting in: "Hello, World!"

This uses CP-1252 encoding

Previous version:

"Hello, World!

11Ÿ™, That's right, I just trademarked Ÿ. You cannot use it without doubling your code golf score :P – Conor O'Brien – 2016-02-11T23:37:36.330

2@CᴏɴᴏʀO'Bʀɪᴇɴ Hahaha, fair enough then :p – Adnan – 2016-02-12T11:50:59.363

8

# beeswax, 15 bytes

Finally the first esolang I created is ready for use. I started working on beeswax as an esolang on a hexagonal grid parallel to Martin Büttner’s Hexagony, but he got finished his well before my language, as it took me quite a while to get everything right. So, here is the second esolang working on a hexagonal grid. ;)

A short hello world program is rather unspectacular, as the  character toggles output to STDOUT.

So, here are the two short, but boring versions:

_Hello, World!

or

*Hello, World!

Or slightly less boring:

!dlroW ,olleH*

_ creates instruction pointers in the horizontal axis, one moving to the right, one moving to the left.

* creates instruction pointers in all main axes, like demonstrated below.

A little more interesting, but 1 byte longer:

!lo olH_el,Wrd

And finally, an even more interesting version, if that’s possible:

r  l
l o

ol*,d!

e H
W

And the same, using the beeswax prettyprint tool:

r     l
l   o

o l  *  , d !

e   H
W

Both of which work because IPs execute their instructions in the reverse order they were created/pushed on the IP stack.

The neighborhood of every cell in a program (named honeycomb) looks like shown below. β marks a bee (instruction pointer), the numbers show the directions of the surrounding cells.

2 — 1
/ \ / \
3 — β — 0
\ / \ /
4 — 5

This would be rather like a beautified version of the actual code, which is stored in a rectangular format like

21
3β0
45

Each bee carries a stack with a fixed length of 3 values around (which isn’t used in the examples above), but they can push values on a global stack of unlimited size, or take values from it, for handling larger amounts of data. The global stack can only do basic stack operations like rotating values up and down. Only bees can do more complex operations like arithmetics or logic operations. All values are 64 bit unsigned integers.

Bees can also drop values to any place on the honeycomb and change its size or modify the source code this way, or they can pick up values from any place on the honeycomb. The contents of the global stack can be written to files, or file contents can be stored in the global stack.

More info, the full specification, an interpreter (with very basic debugging abilities) written in Julia, examples etc. can be cloned from my github page. Pretty much the same information is also available on the esolangs.org beeswax page.

8

# Flummery v3, 165 bytes

Flummery is a BF derivative, but not in the usual sense. It's a meta BF, if you will. There is a pointer, and there is a tape.

[ < > + - ]
^

The > command moves the pointer right one, < moves the pointer left one, . is ., , is ,, and any other character is a no-op. After each character is read, the character pointed to is added to the transpiled code. (At the moment, you'll have to copy+paste the transpiled code into a BF interpreter.) Without further ado, here is the code:

>>>>;;;<<<;;>>>;;<<<;;;>><<<>>><<<>;>><>>;;;;<<>>;;<<>>;;<<>>;;<<<;;;;>>>><<<>>><<<<;;;>>>;;.;<<<;;>>;;;;;.<<;;;>>>;..;<<<;;.;;>>.<;.;;.<;;.;>>;;.<;.;;>>;.;<<<;;;;>>.

All in one textbox:

>>>>;;;<<<;;>>>;;<<<;;;>><<<>>><<<>;>><>>;;;;<<>>;;<<>>;;<<>>;;<<<;;;;>>>><<<>>><<<<;;;>>>;;.
;<<<;;>>;;;;;.<<;;;>>>;..;<<<;;.;;>>.<;.;;.<;;.;>>;;.<;.;;>>;.;<<<;;;;>>.

>>>>;;
;<<<;
;>>>;
;<<<;;
;>>
<<<
>>>
<<<
>
;>>
<
>>;;;
;<<
>>;
;<<
>>;
;<<
>>;
;<<<;;;
;>>>>
<<<
>>>
<<<<;;
;>>>;;
.
;<<<;
;>>;;;;;
.
<<;;
;>>>;
..
;<<<;;
.
;
;>>
.
<;
.
;;
.
<;;
.
;>>;;
.
<;
.
;;
>>;
.
;<<<;;;
;>>
.

Each line represents a single character added to the source code.

oh heavens what have I made

What do the ';' do? A combination of . and ,? – Rɪᴋᴇʀ – 2016-03-14T02:35:13.697

@RikerW any non > or < character is treated as "add the currently pointed at character to the result" – Conor O'Brien – 2016-03-14T02:36:31.097

Oh, okay. That makes sense. – Rɪᴋᴇʀ – 2016-03-14T02:41:44.400

I hate you so much. So, so much. So much. – Fund Monica's Lawsuit – 2016-04-06T21:29:41.903

@QPaysTaxes Thanks mate :) – Conor O'Brien – 2016-04-06T21:29:56.450

"readable version" Don't you mean "very slightly less unreadable"? – HyperNeutrino – 2016-11-30T04:32:37.260

@AlexL. It's much more readable, what are you talking about? :P – Conor O'Brien – 2016-11-30T12:16:20.430

7

## Fueue,  44 4241 40 bytes

Thanks to Ørjan Johansen for saving 2 bytes.

72:108)<101[44+-6:114)32[100 33H]87]:111

Try it online!

### Explanation

Fueue is, as the name suggests, a queue-based language, which is a lot more mindboggling than it sounds (although a lot of that is due to the fact that the program and the data reside in the same queue).

Here is a breakdown of the program's execution (there are no negative integer literals in Fueue, so there's no syntax for them; I'll be representing the minus sign as _ to distinguish it from the negation command -):

Cmd    Explanation               Queue
72     Print 'H'.                :108)<101[44+-6:114)32[100 33H]87]:111
:108   Duplicate 108.            )<101[44+-6:114)32[100 33H]87]:111 108 108
)      Inactive.                 <101[44+-6:114)32[100 33H]87]:111 108 108)
<      Inactive.                 101[44+-6:114)32[100 33H]87]:111 108 108)<
101    Print 'e'.                [44+-6:114)32[100 33H]87]:111 108 108)<
[...]  Inactive.                 :111 108 108)<[44+-6:114)32[100 33H]87]
:111   Duplicate 111.            108 108)<[44+-6:114)32[100 33H]87]111 111
108    Print 'l'.                108)<[44+-6:114)32[100 33H]87]111 111
108    Print 'l'.                )<[44+-6:114)32[100 33H]87]111 111
)      Inactive.                 <[44+-6:114)32[100 33H]87]111 111)
<      Append to block.          111)[44+-6:114)32[100 33H]87 111]
111    Print 'o'.                )[44+-6:114)32[100 33H]87 111]
)      Deblock.                  44+-6:114)32[100 33H]87 111
44     Print ','.                +-6:114)32[100 33H]87 111
+      Inactive.                 -6:114)32[100 33H]87 111+
-      Negate 6.                 :114)32[100 33H]87 111+_6
:      Duplicate 114.            )32[100 33H]87 111+_6 114 114
)      Inactive.                 32[100 33H]87 111+_6 114 114)
32     Print ' '.                [100 33H]87 111+_6 114 114)
[...]  Inactive.                 87 111+_6 114 114)[100 33H]
87     Print 'W'.                111+_6 114 114)[100 33H]
111    Print 'o'.                +_6 114 114)[100 33H]
+      Add -6 and 114.           114)[100 33H]108
114    Print 'r'.                )[100 33H]108
)      Deblock.                  108 100 33H
108    Print 'l'.                100 33H
100    Print 'd'.                33H
33     Print '!'.                H
H      Halt the program.

I guess the more interesting question is how on earth did we get here. I started from the basic "Hello, World!":

72 101 108 108 111 44 32 87 111 114 108 100 33H

My primary goal was to get rid of the duplicate 108 for ll, since Fueue has a duplication command. So the naive thing to try is this:

72 101:108 111 44 32 87 111 114 108 100 33H

The problem is that now the 108 doesn't get printed when its duplicated: every command in Fueue puts the result at the end of the queue. So after printing He, and duplicating the 108 we'd end up with this queue:

111 44 32 87 111 114 108 100 33H108 108

Which would just print o, World! and then halt the program, dropping the ll completely.

So we need to delay the execution of everything from 111 to H until after we had time to print the ll. To delay a piece of code by one cycle through the queue, we can wrap it in a block and "unblock" it:

72 101:108)[111 44 32 87 111 114 108 100 33H]

This works! It prints He, then duplicates the 108, then puts the entire rest of the code after the double 108 so we have this queue now:

108 108 111 44 32 87 111 114 108 100 33H

Which is exactly what we want. But we can save one more byte: since the 108 don't get printed immediately, we're free to move the 72 and 101 around in the program: they're going to be printed in the first cycle through the queue no matter what and the 108s are going to end up after them. So by moving the 101 to the end of the program, we can avoid the space between the two numbers.

At this point, we've got my initial 44-byte solution. But I wanted to get rid of the duplicate 111 as well, which seems kinda possible since one of them is now at the start of the block and we've got swap commands. So the first idea is to split up our block around the 111 and add in a duplicate and swap:

72:108~[44 32 87]:111)[114 108 100 33H]101

Of course, this doesn't quite work. There's a couple of problems here: a) we've got no deblock command for the first block. b) The swap happens on the first cycle through the queue, so it actually swaps the block with the duplication wreaking all sorts of havoc. What we really want is to duplicate the 111, then swap the block between the two numbers, but then we also want to deblock that before printing the second 111. That last part is an issue, because if we don't deblock the block the first time around, the 111 is going to printed on the second cycle (before the block can be executed), but if we do deblock it immediately, we can't swap it between the two numbers as a single unit.

The trick is to use the "append" command instead of swap. Instead of trying to get from here:

[44 32 87]111 111

to here:

111 44 32 87 111

We are going to go here instead:

111[44 32 87 111]

By appending the first copy of 111 into the block, and making use of the automatic move to the end of the queue, we hit two birds with one stone: we've moved the , W characters in between the two os and we've ensured that the second 111 can't be printed before the other characters get deblocked. So the basic idea now looks something like this:

72:108<[44 32 87]:111)[114 108 100 33H]101

There's still an issue: the < should happen on the second cycle, because we need the duplication to happen first. We could go with the )[<] technique we used for the 44-byte solution, but we can also delay it by moving the101between it and its argument (because numbers are not a valid first argument for<, the< will be inactive on the first cyle). We also still need a deblock command for the first block:

72:108)<101[44 32 87]:111)[114 108 100 33H]

Now we're talking. On the first cycle, ) has nothing to deblock so it just moves to the end. Likewise, < has nothing to append we have time to duplicate the 111. On the second cycle, ) still has nothing to deblock, and < appends one copy of the 111 to the block, whereas the other one gets printed. On the third cycle, ) can finally deblock [44 32 87 111], so that they get printed on the fourth cycle. Woohoo, we got Hello, Wo!

But wait: what about the second block? In the current code, it gets deblocked immediately in the first cycle so it would already be executed on the second cycle, printing rld! and terminating the program way too early. The trick is to move it into the first block. That way, it can't possibly be deblocked or executed before those other characters are printed:

72:108)<101[44 32 87)[114 108 100 33H]]:111

We're at 43 bytes now, but we can save two more. This is similar to how we saved the space in the original solution: it doesn't matter where the three numbers inside the outer block appear, because they are going to be printed on the first cycle regardless of where they are. So we can move the ) and the inner block between the numbers to avoid the spaces again:

72:108)<101[44)32[114 108 100 33H]87]:111

This does in fact delay the program by one cycle (because the ) can't deblock the inner block on the first cycle of the outer block), but it doesn't affect the program's result.

The final byte is saved with a bit of arithmetic, courtesy of Ørjan Johansen, to compute the 108 from the 114. The actual code to do so is fairly simple: +-6:114. We make a copy of the 114, we negated a 6 and then add them together to get 108. Since -6 is not a negative literal, but a command applied to a 6, this computation takes two cycles. Thankfully, the : delays the 114 as well, so this just works out. We also now need to remove this from the inner block, so that we have enough time for these two cycles to go through before the d! is printed:

72:108)<101[44+-6:114)32[100 33H]87]:111

Got another byte with arithmetic: Try it online!

– Ørjan Johansen – 2018-03-08T09:33:20.277

@ØrjanJohansen Oh wow, now it's getting crazy. :D – Martin Ender – 2018-03-08T10:34:16.843

7

# Grass, 463 446 bytes

It exits with a crash. Append vw to get a non-crashing version (448 bytes).

wWWWwWWWWwWWWWWwvwwWWwWWWwvWwWwwwwwWWWwWWWwWWWWWwvwWWwwwwwwwwwwwWWWwWWWWWwWWWWwvwWWwwwwwWWWWWWWWWWWWwWWWwvWwwwwwwwwwwwWWwwwwwwWWWWWWWWwWWWWWWWwwWWWWWWwwwwwwwvwWWWWWWWwwwwwwwwwWWWWWWWWWWWWWwWWWwvWwwwwwwwwwwwwwwwwwWWwwwwwwwwwwwwWWWWWWWWWWWWWWWWWwvwWwWwwwwwwwwWwwwwwwWwwwwwwWwwwwwwwWwwwwwwwWwwwwwwwwwwwwwwWWWWWWWWWWWWWWWWWWwvwwWWWWWWWWWWWWWWWWWWWWWWwWWWwwwvWWwWWWWWWWWWWWWWWWWWWWWWwwwwWWwwwwwwwwwWwwwwwwWwwwWwwwwwwwwwWWWWWWWWWWWWwWwwwwwwwwwwwwwwwwww

Try it online!

Based on the TIO example. I think it was from this page by rst76 (613 bytes with lowercase w).

wWWWwWWWWwWWWWWwv                      x -> x + 3
wwWWwWWWwv                             f -> apply f twice (Church numeral 2)
Ww                                     f -> apply f 2**2 = 4 times
Wwwwww                                 x -> x + 4
WWWw                                   x -> x + 8
WWWw                                   x -> x + 32
WWWWWw                                 x -> x + 64
vwWWwwwwwwwwwwwWWWwWWWWWwWWWWw         f -> f(u+2 + 64 + 64 + 32) = f(23)
vwWWwwwwwWWWWWWWWWWWWwWWWwv            f -> f(23 + 8 + 1) = f(32 space)
Wwwwwwwwwwww                           (f->f(32))(x->x+1) = 33 !
WWwwwwww                               (f->f(32))(x->x+8) = 40
WWWWWWWWw                              40 + 4 = 44 ,
WWWWWWWww                              40 + 32 = 72 H
WWWWWWwwwwwww                          (f->f(23))(x->x+64) = 87 U+2
vwWWWWWWWwwwwwwwwwWWWWWWWWWWWWWwWWWwv  f -> f(32 + 64 + 4) = f(100 d)
Wwwwwwwwwwwwwwwwww                     (f->f(100)(x->x+1) = 101 e
WWwwwwwwwwwwww                         (f->f(100)(x->x+8) = 108 l
WWWWWWWWWWWWWWWWWw                     108 + 3 = 111 o
vw                                     begin function
Ww                                       c -> print c; return this function
Wwwwwwwww                                print H
Wwwwwww                                  print e
Wwwwwww                                  print l
Wwwwwwww                                 print l
Wwwwwwww                                 print o
Wwwwwwwwwwwwwww                          print ,
WWWWWWWWWWWWWWWWWWw                      print space
vwwWWWWWWWWWWWWWWWWWWWWWWwWWWwwwv      f = f -> c -> print c; return f(f)
f(f) will return itself as a quine.
WWw                                    Apply the first half of output with
the previous function as argument.
WWWWWWWWWWWWWWWWWWWWWwwww              111 + 3 = 114 r
WWwwwwwwwww                            print U+2
Wwwwwww                                print o
Wwww                                   print r
Wwwwwwwwww                             print l
WWWWWWWWWWWWw                          print d
Wwwwwwwwwwwwwwwwwww                    print !

Generator based on ASCII-only's (too long to post in a comment).

:| explanation pls – ASCII-only – 2018-04-28T02:39:48.853

Or even better, convert to this form if you don't mind

– ASCII-only – 2018-04-28T02:43:18.563

Probably not, I just wanted it to add to RosetTIO to make it easier for other people to attempt to golf it (not that anyone will :P) – ASCII-only – 2018-04-28T06:12:51.513

7

# Backhand, 15 bytes

"ol!,ld elWHro"

Now on Try It Online thanks to Dennis!

Backhand is my first new language, taking inspiration from 2D languages like Befunge and ><>. However, it is 1D, but makes up for the missing dimension by having the pointer move more than one character at a time. Initially, the program starts at location 0 with step count 3.

"  !  d  l  r       " starts a string literal and starts pushing characters to the stack
o  ,     W  o      Change direction and go left when you reach the end
l  l  e  H  "     Switch direction again to go right and end the string literal
H        Halt and output stack

Of course, it looks quite funny, since the program is also an anagram of just "Hello, World!".

7

# evil, 62 58 bytes

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

aeeaeayekeulaaaweevuewpuuuwwlweaaewguwuewpaaawaaawpweeawgw

Uses the instructions:

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

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

Try it online!

7

# Brainetry, 651 bytes

This is a boring golf of the program that comes after this one.

a b c d
a b c d e f g h
a b c d e
a b c d e
a b
a b c d e
a b c d e f g h
a b
a b
a b c d
a b
a b c d e
a b c d e
a b c d e
a b c d e
a b c d e
a b c
a b c
a b c d e f g h i
a b c
a b c d e
a b c d e
a b c
a b c d e
a b c d e
a b c d e
a b c d e f g h i
a b
a b c d e
a b c d e f g
a b
a b
a b
a b c d
a b c d e f g
a b
a b
a b c d e f g
a b c d e f g
a b c d
a b c d
a b c d
a b c d e f g h
a b c d e f g
a b
a b c d e f g h i
a b c
a b c
a b c
a b c
a b c d e f g
a b c d
a b c d
a b c d
a b c d e f g
a b c d e
a b c d e
a b c d e
a b c d e
a b c d e
a b c d e
a b c d e f g
a b c
a b c
a b c d e
a b c d e f g
a b
a b
a b
a b
a b c d
a b c d e f g

Ungolfed but far more interesting to read:

This is a "short"
brainetry program that outputs, to stdout, the message
"Hello, World!" as per the
programming world standard. This standard
dictates that
a user that is trying
a language for the first time should write
as its
first program
this "Hello, World!" program.
Of course,
but that shouldn't
hinder you from
tackling this awesome challenge in the Brainetry programming language.
Me, myself and
I have found this language
to be quite amusing if
used to write
self-referential programs like this one.
Self-referential objects are objects that
I, personally, really enjoy. This
might be because I am just a weird person.
Or not!
Who knows? Certainly not me.
are ALMOST
at the
MIDDLE of
this self referential program.
between self
and referential
in the line above, as it is
NOT a typo, it is missing purposefully.
A very important skill
needed to write Brainetry
programs is one's imagination.
This is because each instruction needs one line
of Brainetry source code on its own.
Sounds easy?
I can assure you, it definitely is not easy.
I'm growing tired,
I'm growing unimaginative,
I'm growing old,
I'm writing code.
Oh boy, I wish that would've rhymed!
Even though I can't
really rhyme in English
because I am unskilled,
I can tell you that this is
exhibiting signs of schizophrenia, right?
At this point I am
pretty much talking to myself,
and no one is listening,
right? No one is listening,
right? I definitely hope not.
Now on to some decent source code,
this program works
by harnessing the
well known power of modular
arithmetic, a really nice thing mathematics has
bestowed upon
us, mortals.
This is,
for real,
from the mathematicians of yor to us.

Builds on top of this awesome brainfuck answer.

1This feels like it isn't a serious contender, since the language only appears to care about the number of words in a line, and there are a lot of words with many more letters than necessary in them. – pppery – 2020-06-10T22:53:49.910

@pppery you are, of course, right. I golfed it and included both the golfed and verbose versions. The verbose version is MUCH funnier to read :) – RGS – 2020-06-11T12:07:42.213

I don't disagree, but I've chosen to focus my energy on objective rule enforcement over reading funny answers. – pppery – 2020-06-12T01:37:24.317

1@pppery yes, thank you for your objectivity :) – RGS – 2020-06-12T06:26:20.567

1@pppery I have just seen your profile again and I find the seemingly-new sentence "But I cannot be dissuaded -- I will keep on hunting for old invalid answers and close-voting questions like I've always done." even more worrying than everything I have ever seen there so far... – the default. – 2020-06-12T11:57:39.600

7

# Ruby, 18 19 bytes

puts"Hello, World!"

Output wasn't quite right. Thanks Martin

Why not p"Hello, World!"? It's only 15 bytes. – John – 2016-01-29T23:37:42.920

1@John: p always always prints quotes around strings. – univalence – 2016-07-18T18:22:46.503

7

# Lua , 22 20 bytes

print"Hello, World!"

Try it online!

Thanks to @mathmandan for saving 2 bytes

1

I don't think you need the parentheses, so you can save two bytes: https://repl.it/BEPR

– mathmandan – 2015-08-28T15:22:22.530

How about ="Hello, World!" – because technically this does output "Hello, World!". – ascx – 2015-09-07T16:26:10.430

1@Socialz I just relized(thanks to you) that the = is not even necessary. – jakebacker44 – 2015-09-07T16:29:28.430

@JakeBacker I can't reproduce that though, heh, which version are you running? – ascx – 2015-09-07T16:30:59.757

@Socialz http://repl.it/BGIS

– jakebacker44 – 2015-09-07T16:31:35.920

@JakeBacker Cool! In that case this works as well [[Hello, World!]]. Yours is obviously shorter, though. – ascx – 2015-09-07T16:33:40.210

7

## Retina, 14 bytes

Hello, World!

Try it online!

A program with two lines describes a single regex replacement. Here, we just replace the empty string (i.e. the input) with the desired output.

For one additional byte, we can make it work with non-empty input, by using a constant stage:

KHello, World!

Try it online!

7

main=putStr"Hello, World!"

Try it online!

Putting one of the many compilers you downloaded for PLQ to good use I see. ;) – Alex A. – 2015-08-28T16:52:10.403

7

# Yorick, 21 bytes

write,"Hello, World!"

Yorick is a fast programming language for scientific number-crunching and graph-potting. It's relatively unknown and doesn't distinguish itself too much from other languages like R, but this Y-language completes the alphabet. Whoo!

3+1 for completing the alphabet. Also for answering like 20 times. – AdmBorkBork – 2015-08-28T19:02:22.383

7

# Mind, 26 bytes

The program is encoded in Shift_JIS:

ﾒｲﾝは
"Hello, World!"
表示

It means something like:

MAIN is:
"Hello, World!"
display

As you can see, Mind is a Japanese programming language. It's based on Forth, which turns out to suit Japanese's SOV word order rather well!

7

# Trigger, 40 bytes

HHHeeelll#lllooo,,,   WWWooorrrlllddd!!!

Trigger is pattern-based, so commands are symbol independent. Three of the same character outputs that character to STDOUT.

The # is to introduce a break in the middle so that the double l doesn't turn into a six-long pattern, which will not decompose as intended. A single char is a NOT operation, but it is irrelevant for our purposes.

Can you only go 1 letter at a time? Or could you say Hello, World!Hello, World!Hello, World! which would be 1 character shorter because it doesn't need the "#"? – Albert Renshaw – 2015-09-29T21:23:17.217

@AlbertRenshaw Trigger is based on patterns, and three of the same char in a row outputs. A pattern of AAB (e.g. llo) is a jump operation, and any other one-char pattern is NOT. So the example you give would be a lot of NOTs and jumps, rather than outputs. – Sp3000 – 2015-09-29T23:14:06.133

7

# 7, 45 bytes

### (Important note: 7 is an unpublished esolang of my creation.)

4**++o/++d*no++doo:+do:/+no---*+uo+duo--o/++o

7 is a stack-based esolang of my invention. It has no built-in String or Array support, and you can't even push a specified number to the stack (with a few exceptions), so everything has to be done by hand. Here's what each operator does:

• 4 sets variable b to 4. This can only be done at the beginning of the program. 7 is the default value, hence the name.
• Arithmetic +-*/ works as you would expect, but operates between the top item and b. (This is changable, but this program doesn't change it.)
• n and d increment and decrement the top item by 1, respectively.
• : duplicates the top item.
• o outputs the top item, while u outputs and pops the top item.

This program outputs the ASCII values of the proper characters. There are a bunch more operators which have a bunch more jobs, but I won't go into detail right now. I'm planning to publish it as soon as I have enough time.

7

# Bodyless HTTP response headers, 134 bytes

HTTP/1.1 200 OK
content-type: text/html
content-length: 0

It is a valid http-response headers set. They have to be followed by 2 newlines \r\n\r\n. The response body is empty. Firefox can handle such response and shows an HTML page with Hello, World! text.

Line breaks are counted as 2 symbols, according to HTTP specification. The 2 trailing newlines are not counted as they do not belong to the headers themselves.

Does it work if you omit content-length and just close the connection? – jimmy23013 – 2015-09-04T08:04:00.957

@jimmy23013, I didn't check it. I expect your version to work, but it won't be a valid response as I understand. – Qwertiy – 2015-09-04T10:50:51.790

1

Is this a programming language? No, it's not. It can't represent natrual numbers in a mathematically useful way, it cannot represent tuples, it cannot check for primes, and it cannot add two natural numbers. see eg here

I'm not sure if programming language-ness actually matters for this challenge; it's just a note.

– cat – 2016-06-28T13:42:02.517

7

# Self-modifying Brainfuck, 28 19 bytes

represents a literal NUL byte.

<[.<]␀!dlroW ,olleH

Try it online

This is my Python interpreter that is referenced on the Esolangs page for SMBF. The default/example program is the program above. The SMBF code is entered on line 178 so that the Input box can be used for STDIN.

If input is not empty, it would need to be this (20 bytes):

<[.+<]␀!dlroW ,olleH

Since SMBF has its own source code on the same tape, we put the string on the tape in reverse to facilitate printing. Then we print all the cells from right to left up to the cell with zero in it (the cell represented by ). After printing, I have to change the comma to a different character so it doesn't look for input. Using + changes it to a - and vice versa, so either way it's a no-op (not that it matters, since printing is done anyway).

The second version could be just <[.+<]\x00!dlroW ,olleH, couldn't it? – primo – 2016-07-27T12:55:48.230

@primo Yeah, it could. – mbomb007 – 2016-07-28T14:16:08.157

1Doesn't the second version work even with input? Sure, it'll read a byte of input, but the program does the same thing regardless of whether any byte or EOF is read. – None – 2017-05-01T01:13:02.140

Taking input when you're not supposed to isn't allowed. That's what the 2nd program is assuming. – mbomb007 – 2017-05-01T14:29:43.343

7

# ferNANDo, 111 109 bytes

7 7
3
5 5
6 5
4 3 3
0 5 3 0 7 3 0 0
0 5 7 0 0 5 0 4
0 6 5 2 4 6 2 3
0 6 6 0 7 7 2 3
0 6 6 2 5 4 7 4
2 2
3 5
3

The above loops three times, printing five characters each time, trailing with \r\n, which I am considering to be a single newline. The general setup I use to loop three times is the following:

7 7
3
5 5
6 5
4 3 3
1 6 6
0 0 7 7 0 0 0 0
0 0 7 7 0 0 0 1
0 0 7 7 0 0 0 2
0 0 7 7 0 0 0 3
0 0 7 7 0 0 0 4
0 0 7 7 0 0 0 5
0 0 7 7 0 0 0 6
0 0 7 7 0 0 0 7
0 0 0 0 7 0 7 0
2 2
3 5
3

producing:

00001111
00110011
01010101

which I think makes the variable names 0-7 somewhat evident. In this arrangement the value 1 is not needed, saving 6 bytes.

7

## MATL, 15 bytes

'Hello, World!'

A string literal is pushed onto the stack. It gets implicitly printed at the end of the program.

1Is it finished? Congratz! Looking forward to seeing it in use. I'll hopefully have the chance to check it out one day :-) – Stewie Griffin – 2015-12-12T17:09:49.203

1@StewieGriffin Not sure if it's "finished"... let's just say "stable enough". It's in version 1.0.0. But yes, it's an official version now. Being an experienced Matlab user, I hope you'll find it interesting! – Luis Mendo – 2015-12-12T17:13:02.803

7

# Binary-Encoded Golfical, 40+1 (-x flag)= 41 bytes

Can be transpiled back into the standard graphical version using the included Encoder utility, or run directly using the -x flag.

Hex dump:

01 90 01 00 48 18 00 65 18 00 6C 18 18 00 6F 18
00 2C 18 00 20 18 00 57 18 00 6F 18 00 72 18 00
6C 18 00 64 18 00 21 18

Original image:

Zoomed in by a factor of 16:

Explanation: Uses the active cell to store values, and prints them as characters

7

## Glava 1.4, 16 bytes

Edit: from Doorknob's and ConorO'Brien's suggestions, the name has changed to Glava.

p("Hello, World!

Glava is a golfing Java dialect (obviously). It adds shorthands to many keywords and common phrases in Java code. So, the code above actually corresponds to the Java code:

System.out.print("Hello World!")

You may be wondering, where does the ") come from? Well, Glava has a feature where it automatically adds closing brackets and double quotes. Also, when a closing curly bracket is needed, it places a semicolon before it.

Another neat feature is that if you do not specify a main class or method, it will do it for you. So the compiled code in the end looks like:

public class Main {public static void main (String[] A) { System.out.print("Hello World!");}}

1FREAKING FINALLY! Suggestion: Add a piece of code that completes quotes, parens, and } <-- those so you can omit the last four chars. (Maybe a little AIS could help here?) – Conor O'Brien – 2016-01-03T17:46:29.093

Java for golf, but there's STILL a freakin' semicolon! – cat – 2016-01-03T18:21:38.793

@cat yeah, I know. Me and Conor are trying to figure out how to avoid having to use it. – GamrCorps – 2016-01-03T18:22:48.663

3@cat well, Glava 1.2+ supports semicolon insertion before closing curly brackets, so it fixes that problem – GamrCorps – 2016-01-04T16:38:11.830

7

# Pris, 107 bytes

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

Try it out here! And here's an explanation!

(][[[]]( ; 72
}]       ; out H
)]]]])   ; 32
{]       ; 72 -> reg
(]]][    ; r += 29
}]       ; out e
(]]      ; r += 7
}]       ; out l
{]]]     ; nop
}]       ; out l
(]       ; r += 3
}]       ; out o
{]       ; set r to 72
}]]]     ; nop
{{       ; change focus
}]]]     ; nop
{]       ; 32 -> reg
(][](    ; r += 12
}]       ; out ,
{]       ; set r to 32
}]       ; out " "
{        ; change focus
(]]]     ; r += 15
}]       ; out W
(]][     ; r += 13
{]       ; 100 -> reg
(][]     ; r += 11
}]       ; out o
(]       ; r += 3
}]       ; out r
{]       ; reg -> r
)        ; "nop"
{]       ; r -> reg
(]](     ; r += 8
}]       ; out l
{]       ; reg -> r
}]       ; out d
{{       ; change focus
}]       ; out !

Now aren't you ready to take on the world? Haha, here's some help. From the README:

Pris has six functional characters, but has more commands than that. Strings of symbols have different meanings according to their number.

A Pris program is comprised of a series of meta-commands, or keywords. A keyword is made of a series of one of any of the four main construction symbols ((, ), {, and }) and some modifier symbols ([ and ]). It must start with a constructoin symbol, and this denotes a change in meta-command. For example, the string (([[][()]])[) has two meta commands: (([[][( and )]])]).

[...]

There are two registers, designated LEFT and RIGHT. One of them is "focused" and the other is "unfocused".

In the above explanation, r is the focused register. reg is the external register for holding other values. It cannot be focused on, but only accessible using {{{, or {].

3My only words are "O_o" – Downgoat – 2016-03-15T02:46:38.830

@Downgoat Then I have done my job. – Conor O'Brien – 2016-03-15T02:50:02.747

7

# Sesos, 24 21 bytes

0000000: 2845ee adaa55 ddcabd 123596 b32b71 5f398a 23b577  (E...U....5..+q_9.#.w

Try it online! Check Debug to see the generated binary code.

I tried several less straightforward approaches – including a port of @primo's brainfuck answer – but they all turned out longer.

### How it works

The binary file above has been generated by assembling the following SASM code.

add 72  ; Set cell 0 to 72.
put     ; Print 'H'.
fwd 1   ; Advance to cell 1.
add 101 ; Set cell 1 to 101.
put     ; Print 'e'.
add 7   ; Set cell 1 to 108.
put     ; Print 'l'.
put     ; Print 'l'.
add 3   ; Set cell 1 to 111.
put     ; Print 'o'.
fwd 1   ; Advance to cell 2.
add 44  ; Set cell 2 to 44.
put     ; Print ','.
sub 12  ; Set cell 2 to 32.
put     ; Print ' '.
rwd 2   ; Retrocede to cell 0.
add 15  ; Set cell 0 to 87.
put     ; Print 'W'.
fwd 1   ; Advance to cell 1.
put     ; Print 'o'.
add 3   ; Set cell 1 to 114.
put     ; Print 'r'.
sub 6   ; Set cell 1 to 108.
put     ; Print 'l'.
sub 8   ; Set cell 1 to 100.
put     ; Print 'd'.
fwd 1   ; Advance to cell 2.
add 1   ; Set cell 2 to 33.
put     ; Print '!'.

How does this end up being shorter than the trivial solution when assembled? http://codegolf.stackexchange.com/a/86567/34718

– mbomb007 – 2016-07-25T19:39:02.967

Because the arguments to add and sub are considerably smaller. Arguments are encoded in bijective binary, and each digit requires 3 bits. – Dennis – 2016-07-25T19:42:27.437

6

# Casio Basic, 15 Bytes

"Hello, World!"

I think it explaines itself well enough...

Hello, and welcome to PPCG! This is a good answer; the downvote was an automatic Community downvote (AFAIK), and I cancelled it with an upvote. – NoOneIsHere – 2017-05-30T20:16:47.073

Thanks and sorry that I messed up the formatting, I'm not really used to yet... – ADDB – 2017-05-30T20:17:59.273

Perfectly OK! Just use four spaces before code, and a pound sign (#) or two before your header. – NoOneIsHere – 2017-05-30T20:18:43.593

6

# 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 – HyperNeutrino – 2017-06-15T00:45:44.843

@HyperNeutrino It's rather complex. Wait for the explanation :P – MD XF – 2017-06-15T00:46:23.870

you should change the title on this – Destructible Lemon – 2017-06-15T01:32:11.703

Also that is not postfix – Destructible Lemon – 2017-06-15T01:32:43.307

@DestructibleLemon oh duh – MD XF – 2017-06-15T01:38:41.947

The output is incorrect: the w should be a W. – Dennis – 2017-06-17T01:35:53.843

@Dennis Crud, just a minute... – MD XF – 2017-06-17T01:36:23.543

6

# MY, 73 bytes

Here's the hex:

07 24 21 21 28 26
0A 24 21 28 26
0B 24 20 20 28 26
0B 24 20 20 28 26
0B 24 21 28 26
04 24 21 21 21 21 28 26
02 25 28 26
09 24 20 20 20 28 26
0B 24 21 28 26
07 25 21 21 28 26
0B 24 20 20 28 26
0A 24 28 26
02 25 21 28 26

I didn't want to update my old answer, because this one isn't just a simple one-byte solution that uses a builtin.

How it works: Outputs each character by using the few commands I have interpreted:

• Number Literal: 0x00 - 0x0F
• Minus 1: 0x20
• Times 10: 0x24
• Times 16: 0x25
• Output: 0x26
• Character value: 0x28

1Someone upvoted this, wow. – Zacharý – 2017-07-23T14:23:20.123

you should make a codepage for this. – Destructible Lemon – 2017-08-22T03:30:18.407

I already have a codepage: https://codegolf.stackexchange.com/questions/139824/turn-an-integer-n-into-a-list-containing-it-n-times/139894#139894 is an example of its usage.

– Zacharý – 2017-08-22T14:41:14.740

6

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

6

# Pyramid Scheme, 857 bytes

^      ^      ^     ^      ^      ^      ^      ^      ^      ^      ^      ^      ^
/ \    / \    / \   / \    / \    / \    / \    / \    / \    / \    / \    / \    / \
/out\  /out\  /out\ /out\  /out\  /out\  /out\  /out\  /out\  /out\  /out\  /out\  /out\
-----^ -----^ -----^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^-----
/ \    / \    / \    / \    / \    / \    / \    / \    / \    / \    / \    / \
/chr\  /chr\  /chr\  /chr\  /chr\  /chr\  /chr\  /chr\  /chr\  /chr\  /chr\  /chr\
^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^-----
/ \    / \    / \    / \    / \    / \    / \    / \    / \    / \    / \    / \
/72 \  /101\  /108\  /111\  /44 \  /32 \  /87 \  /111\  /114\  /108\  /100\  /33 \
-----  -----  -----  -----  -----  -----  -----  -----  -----  -----  -----  -----

Try it online!

Wow. At least it's kinda clear how this works...

6

# AArch64 machine language Linux, 48 45 bytes

0: d2800020 mov x0, #0x1       ; stdout is fd=1
4: d28001a2 mov x2, #0xd       ; length of string
8: 94000001 bl  c              ; put addr of pc to x30
c: 910053c1 add x1, x30, #0x14 ; put addr of string to x1
10: d2800808 mov x8, #0x40      ; select write() syscall
14: d4000001 svc #0x0           ; syscall
18: d2800bc8 mov x8, #0x5e      ; select exit() syscall
1c: d4000001 svc #0x0           ; syscall
20: 6c6c6548 "Hello, World!"
77202c6f
646c726f
21

To try it out on an AArch64 Linux machine or Android device with Termux, compile and run the following C program. You may need to pass the -zexecstack argument to the compiler.

const char main[]=" \0\x80\xd2\xa2\1\x80\xd2\1\0\0\x94\xc1\x53\0\x91\b\b\x80\xd2\1\0\0\xd4\xc8\v\x80\xd2\1\0\0\xd4Hello, World!"

6

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

6

# Symbolic Python, 175 157 147 136 bytes

_=-~(_==_)
_*=_-~_
__=_*_+~-~-_
_=('%'+''[~_/_])*-~-~_%(~-_*~-~-_,_*_+_/_,__,__,_*_-~_,',',' ',__-_+~_,_*_-~_,_==_[_/_],__,_*_)+'!'

Try it online!

I'm not sure this is optimal, but it sure was fun.

### Explanation:

_=-~(_==_)           # Set _ to 2
_*=_-~_              # Set _ to 2*(2+2+1) = 10
__=_*_+~-~-_         # Set __ to 10*10+(10-1-1) = 108
_=                   # Set _ to
('%'+''[~_/_])      # %c, where c is coming from the character \x0c
*-~-~_                # Repeated 12 times
%(...                 # Then format into that format string
~-_*~-~-_,              # (10-1)*(10-1-1) = 72  = 'H'
_*_+_/_,                # 10*10+1         = 101 = 'e'
__,                     #                   108 = 'l'
__,                     #                   108 = 'l'
_*_-~_,                 # 10*10+10+1      = 111 = 'o'
',',                    #                         ','
' ',                    #                         ' '
__-_+~_,                # 108-10-(10+1)   = 87  = 'W'
_*_-~_,                 # 10*10+10+1      = 111 = 'o'
_==_[_/_],            # second letter of True = 'r'
__,                     #                   108 = 'l'
_*_                     # 10*10           = 100 = 'd'
)+'!'                   # Then add the last char    '!'
# And implicitly print _

6

# 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." https://www.princeton.edu/~hos/mike/transcripts/thompson.htm

– roblogic – 2019-08-27T01:53:36.577

6

# Plumber, 1606 445 bytes

[]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
[[]=]=]=]=]=]=]
]
[[]=]=]=]=]=]=]=]=]=]=]=]=]
]
]
]
]
]
]
]
]
]
]
]
[[]=]=]=]=]=]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
[[]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
[[]=]=]=]=]=]=]=]
]
]
]
]
]
]
]
]
]
]
]
]
]
[[]=]=]=]=]=]=]=]=]=]=]=]
]
[[]=]
]
]
]
]
]
]
]
]
[[]=]=[[[[]=]=]=]=]=]=[]
]
]
]
[[]=]=]=]=[[]=]=]=[]
]
]
]
][]=]=]=]=]=]=]=]=]=[]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]
][[=

With some modifications of an idea by @dzaima, I've golfed 1161 bytes off of this. This one uses a single falling packet, incrementing each time it falls, and forks it off each time it reaches the right value to be outputted.

### Old version

[]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
[[[[[[[[[[[[[[[[[[[[[[[[[[
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
] ] ] ]     ]
[[[[[[[[[]]
] ] ] ]     [ ]
] ] ]     [ ]
] ] ]     [ ]
] ] ]     [ ]
] ] ]     [ ]
] ] ]     [ ]
] ] ]     [ ]
] ] ]     [ ]
[[[[[[
]     [ ] ]
]     [ ] ]
]     [ ] ]
[   ]
[   ]
[   ]
[
[
]
]
]
]]]]]]]]]]]]]]]]]]]]]]]]]]
][[=

It's a little long. I could probably steal some tricks from a BF solution, maybe.

In Plumber, the program is divided into units, each of which are 2 characters wide. Each line is padded to the length of the longest line with spaces, which can be used to shorten programs. Each ] unit is an increment operator on a falling packet of information, which is dropped by the [] at the top. Chains of [[ can be used to duplicate packets and drop them one by one in different columns.

2@downvoter Please explain? I worked pretty hard to golf this down from over 2500 bytes. It's a new language, but according to the challenge spec, Unlike our usual rules, feel free to use a language (or language version) even if it's newer than this challenge. – Redwolf Programs – 2019-12-09T23:50:19.947

2Wish I could vote this up a second time; sweet golf! – squid – 2019-12-11T11:36:36.470

6

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

6

# PowerShell, 15 Bytes

Likely in Foo (among others) as well, but I'll let someone with more knowledge of those languages post.

"Hello, World!"

or, alternatively,

'Hello, World!'

In PowerShell, both ' and " denote string literals. The difference is the double-quotes will expand variables (e.g., $myString) and escape characters (e.g., n), while the single-quote will treat everything literally. PowerShell does an implicit Write of anything that's on a line by itself in a program (the relative merits of Write-Host vs Write-Output are left as an exercise to the reader) -- variable, literal string (as this is), result of a one-line command, etc. This stems from the fact that every line gets executed, and the way to execute a string is to print it. For other data types, if they have a way to convert to a string, the execution silently does the conversion in the background and then prints the resultant string. If there's no way to get a string, you'll wind up printing a description of the datatype. This is one of the ways that PowerShell, as ... verbose clear ... as it is, can wind up somewhat competing with other languages. A short article on the topic, not written by me, though the author and I have a similar name. 6 # APL, 17 bytes ⎕←'Hello, World!' This is the portable way of printing from a full program. In the ngn/apl demo, you can omit the ⎕← for 15 bytes. 6 # Pascal, 32 bytes begin write('Hello, World!')end. 6 # C++, 48 bytes (must be compiled with g++) puts is slightly more concise than std::cout, shaving 6 bytes off of the other c++ answer. #include<cstdio> main(){puts("Hello, World!");} 1With g++, you can eliminate the space on line 1 and the int on line 2. – Dennis – 2015-08-29T03:56:55.873 @Dennis, done. I think this is the shortest possible in C++. – James – 2015-08-29T07:02:26.803 3This is not legal C++ code. The return type of main must be int and cannot be empty. – Hubi – 2015-08-31T09:34:16.133 @Hubi but it does correctly compile and run if you use g++. – James – 2015-08-31T15:58:35.717 @DJ yes, but only because of the C compatibility of the C++ compiler! If you compile your source with the flag "-Wall", you get a warning that ISO forbids no return type! – Hubi – 2015-08-31T19:45:56.530 int puts(...); instead of #include<cstdio> makes it 3 bytes shorter. Or not... – Qwertiy – 2015-09-03T10:38:04.570 In Obj-c you can use #import instead of #include, 1 shorter :D – Albert Renshaw – 2015-09-29T21:26:56.827 1@DJMcMayhem The fact, that compiler compiles something, does not mean, that it is correct. C++ does not support default int. – Zereges – 2015-10-25T11:20:12.577 @Zereges This was discussed on [meta[(http://meta.codegolf.stackexchange.com/questions/5851/are-compiler-specific-submissions-allowed). – James – 2015-10-25T21:15:12.233 In this code yields two errors with g++ in Mac OS. – CroCo – 2016-01-04T10:57:11.583 1It's 47 bytes, not 48 – ASCII-only – 2017-08-18T12:14:46.707 6 # Beatnik, 148 Bytes It could probably be done better, but this is one of the first times I used a stack based language. Beatnik determines commands and values based in the scrabble score for the words, but it (thankfully) doesn't check them against a dictionary. K QQQQQQQG ZD XO K QQJA KD ZD XO K KG KD ZD ZD ZD XO XO K B KD ZD XO K QQQQF ZD ZD XO K QQQD XO K A Z KD XO ZD XO K B KD XO ZD XO K J Z XO K QQQB XO Python interpreter can be found here A breakdown of what I've done K QQQQQQQG # push 72 72 ZD # duplicate 72 72 XO # output H 72 K QQJA # push 29 29 72 KD # add 101 ZD # duplicate 101 101 XO # output e 101 K KG # push 7 7 101 KD # add 108 ZD # duplicate 108 108 ZD # duplicate 108 108 108 ZD # duplicate 108 108 108 108 XO # output l 108 108 108 XO # output l 108 108 K B # push 3 3 108 108 KD # add 111 108 ZD # duplicate 111 111 108 XO # output o 111 108 K QQQQF # push 44 44 111 108 ZD # duplicate 44 44 111 108 ZD # duplicate 44 44 44 111 108 XO # output , 44 44 111 108 K QQQD # push 32 32 44 44 111 108 XO # output <space> 44 44 111 108 K A # push 1 1 44 44 111 108 Z # subtract 43 44 111 108 KD # add 87 111 108 XO # output W 111 108 ZD # duplicate 111 111 108 XO # output o 111 108 K B # push 3 3 111 108 KD # add 114 108 XO # output r 108 ZD # duplicate 108 108 XO # output l 108 K J # push 8 8 108 Z # subtract 100 XO # output d K QQQB # push 33 33 XO # output Can you add Scrabble scores to the explanation? – CalculatorFeline – 2017-06-05T04:34:02.307 The version using valid scrabble words is only 100 bytes longer. – pppery – 2017-08-02T00:44:49.627 6 # Deadfish~, 1 byte w Hooray for built-ins. 6 # Parenthetic, 766698 630 bytes ((()()())(()())((()())((()()())(()()()()))((()(())(())())((()(()))((()()(()))(()()())((())()()()()()()()()()()()()()))((()()(()))((())()()()()()())((())()()()()()))(()()()())))))((()(()))((()())((())()()())((())()()()))((()())((())()()()()())((())()()()()()()))((()())((())()()()()()())((())))((()())((())()()()()()())((())))((()())((())()()()()()())((())()()()))((()())((())())((())()))((()())((()))((())()()))((()())((())()()()())((())()()()()()))((()())((())()()()()()())((())()()()))((()())((())()()()()()())((())()()()()()()))((()())((())()()()()()())((())))((()())((())()()()()())((())()()()()()))((()())((()))((())()()()))) Try it online! Still got a lot to golf. This version uses a single definition (define f (lambda (a b) (char (+ (* a 13) 30 b)))) In other words, each char is encoded by two numbers a and b, for which 30 + 13*a + b is calculated (e.g. H = 73 = 30 + 3*13 + 3) . nice work ... I thought it could be done better – MickyT – 2015-09-04T01:01:12.943 608 bytes using (define f (lambda (a b) (char (- (* 6 19) (* a 13) b)))) – Leaky Nun – 2017-08-23T11:00:14.397 604 bytes after golfing Leaky Nun's answer slightly – Sherlock9 – 2017-08-23T13:07:15.317 6 ## Mascarpone, 29 bytes [!dlroW ,olleH]$.............

The esolangs page notes that

from a typical programmer's point of view, it is not obvious how to program in it

In fact, although the language's designer believes it to be Turing complete, and I personally respect his expertise in esoteric languages enough to take it on trust that it's at the very least a non-trivial language, I haven't figured out how to write a loop. So what this does is to push the characters [!dlroW ,olleH] onto the stack (the [] delimiters are necessary, and do for some reason end up on the stack too), pop the ] with $, and then print everything except the [, one character at a time. 2I know this is way late, but you can loop by having an operation call itself [!dlroW ,olleH]$[/.:!]v*:! – BlackCap – 2017-07-21T14:57:23.587

6

# Shtriped, 199 bytes

e n
e b
i b
+ x y
+
i x
d y
+
+
d x
0
+ b b b
1
+ b n n
0
A
1
0
B
0
1
1
1
1
A
0
0
B
1
1
A
0
A
0
0
B
1
A
0
B
A
0
B
1
A
A
A
0
0
B
A
A
1
A
B
A
A
1
1
1
A
A
B
1
A
B
1
A
A
1
A
A
A
1
A
B
s n

(Tested in v1.0.0. Does not output trailing newline.)

Shtriped has no strings, only non-negative arbitrary precision integers. But you can print strings by encoding them as integers.

The integer that encodes Hello, World is 46758282851806618588827407. Every two digits essentially encodes one character in offset ASCII order, 82 is l, 85 is o, etc. The program basically declares the variable n to 0, and increments it one by one until it is 46758282851806618588827407, then prints it as a string. (In Shtriped, any integer larger than 0 needs to be incremented one by one to get there.)

Incrementing that high is obviously impossible in any reasonable amount of time, (a 3Ghz processor could maybe do it in 500 million years) so don't run this program, you will never see it finish! However, I am certain that it would finish, it if had the time. It should never run out of memory or have a stack overflow thanks to tail recursion optimization.

To explain what's really happening, here's a nearly identical program that will finish in a few seconds, outputting Hel. Everything is the same except the large column of 01AB's above the last line.

e n \ declare n to 0, this is the variable that will be incremented to that huge number
e b \ declare b to 0, this is the binary place value that will keep getting doubled
i b \ increment b, making it 1

+ x y \ define a function called "+" that returns x + y
+    \ define a nested function also called "+"
i x \ increment x
d y \ decrement y unless y is 0, in that case return the last statement's value
+   \ recursively call self
+    \ call nested "+"
d x  \ decrement (and return) x, since we will have over counted by 1

0 \ define a function called "0" that adds b to itself, doubling it
+ b b b
1 \ define a function called "1" that adds b to n, then calls 0
+ b n n
0

\ at this point we could set n to be any number by calling 0 and 1
\ according to the desired number's reversed binary representation
\ but these A and B helper functions help golf that part
A \ calls 1 then 0
1
0
B \ calls 0 then 1
0
1

\ call functions 0 1 A B to increment n to the desired number
B
1
1
1
1
A
0
A
0
0
A
B
1
1
\ expanding the B's and A's, this becomes 0111111001000100111
\ which reverses to 1110010001001111110 in binary
\ which is 467582 in decimal
\ which is the encoding of the string "Hel"

s n \ finally, print n as a string

Note that I'm very doubtful this answer is optimal for Shtriped. Printing each character of Hello, World! or some combinations of its substrings could be much shorter, but doing that would require lots of trial and error and mathematical calisthenics (or at least a better golfer). For now, I like this elegant, if suboptimal solution.

6

# Brain-Flak, 180, 176, 170 + 3 = 173 bytes

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

Try it online!

This code is 170 bytes long, but adds three bytes for the -A flag, which is required to force brain-flak to input and output in ASCII. One little detail is that this also requires the -r flag, but it did not when I first wrote this answer, so I am not adding one byte for it.

I'd post a detailed explanation, but this language hurts my brain...

Thanks to @Wheatwizard for saving 4 10 bytes!

Crossed out 4 is still regular 4... :(

1

You can save two bytes by moving the last 3 in the first push portion to the beginning and popping it for the first 3. (Since that is probably confusing here is a try it online)

– Wheat Wizard – 2016-09-06T17:49:54.270

You can also change ([]){} to [][]. (try it online)

– Wheat Wizard – 2016-09-06T17:51:52.237

@WheatWizard Good tips, thankyou! – James – 2016-09-06T17:53:32.200

You can change (({})){}([])[](){} to (({}))[]{}[][](). (try it online)

– Wheat Wizard – 2016-09-06T18:11:19.767

Ok, two more: try it online

– Wheat Wizard – 2016-09-06T18:19:48.013

Another two: try it online

– Wheat Wizard – 2016-09-06T18:21:33.670

6

# V, 14 bytes

iHello, World!

Try it online! This enters insert mode, then inserts Hello, World! into the field.

5

# Chip, 174166106 97 bytes

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

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

Try it online!

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

Ungolfed (134 bytes):

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

How the ungolfed version works:

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

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

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

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

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

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

Golfing it:

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

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

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

5

# K (oK), 20 19 bytes

!0:"Hello, World!"

Try it online!

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

### Alternative solution, 20 bytes, clean exit

{}0:"Hello, World!"

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

Try it online!

### Almost-solutions

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

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

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

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

6You know you've attained master rank when you don't know why your code golf works, but it still does. – AdmBorkBork – 2017-02-09T20:20:47.220

Of course. The true&tested method of "Can't possibly work, let's try it anyway." ~ Eugene van der Pijll – primo – 2017-02-10T11:16:40.570

5

## Alice, 19 18 bytes

Thanks to Sp3000 for saving 1 byte.

"&O@!dlroW ,olleH

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

"!dlroW ,olleH"d&O@

Try it online!

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

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

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

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

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

Try it online!

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

"Hello, World!"o@

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

5

# Aceto, 19 bytes

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

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

1Golfed 16+1=17 for -l flag – drham – 2018-03-09T20:28:11.537

5

# Husk, 8 bytes

¨H◄⁰,ω]!

Try it online!

Husk got compressed strings!

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

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

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

5

# Windows Portable Executable (PE), 1175 bytes

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

extern ExitProcess, GetStdHandle, WriteConsoleA

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

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

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

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

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

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

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

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

As a bonus, this executable also works on DOS.

If anyone wants to try golfing this down some more, they may find this answer on SO and the material it references helpful.

– 3D1T0R – 2018-05-29T19:53:14.510

1https://github.com/pts/pts-tinype Some smaller Hello World .exes, not mine. I couldn't get the 268-byte ones to run at all, and the 402-byte one would only run with my antivirus shut off. – Nnnes – 2018-07-23T11:19:59.800

5

# Magic Number, 174 bytes

0010000033001000010000100001080010000114001000011100100000870010000032001000004400100001110010000108001000010800100001010010000072006006006006006006006006006006006006006006

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

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

1Welcome to PPCG! – Martin Ender – 2017-08-13T17:35:04.527

5

# Pain-Flak, 152 bytes

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

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

Try it online!

### How it works

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

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

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

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

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

• Line 1 pushes garbage on the first stack.

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

This switches to the second stack.

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

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

You care if i use the pain-flak description for my readme? – Christopher – 2018-01-21T00:17:59.337

@Christopher2EZ4RTZ Go ahead. :) – Dennis – 2018-01-21T00:19:25.163

5

# Brain-Flak, 144 138 bytes

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

Try it online!

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

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

### How It Works:

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

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

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

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

This part pushes "ello, "

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

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

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

3I'm not going to let a computer beat me – Wheat Wizard – 2018-03-12T21:06:12.823

2@WheatWizard Really? :> – Jo King – 2018-03-13T10:50:17.283

1I will not. – Wheat Wizard – 2018-03-13T23:19:50.957

5

Logo (programming language) - 20 bytes

PRINT [Hello, World!]

Or even more exciting version:

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

lt 90 pu fd 200 pd rt 90 helloworld

Output:

Welcome to PPCG! This is code golf, so you should make sure that your answer is as short as possible. I don't know Logo, but it seems the HELLO is an arbitrary identifier, so you can probably shorten it and maybe it's also possible to get rid of some of that whitespace? Also, please use the required spelling Hello, World! and include the byte count of the code in your answer so that people can easily see its score. – Martin Ender – 2018-04-10T15:04:10.273

First-timer here. Cool, thanks. – Artur Kędzior – 2018-04-10T15:09:48.607

3Hmm. I think you should stop drawing in between letters – ASCII-only – 2018-05-18T10:02:38.833

5

# Whirl, 955 733 bytes

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

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

1100001110010001111100110000000000000100000100000100000110000010000100100010001000000000000111110001111000111110001111000000000000011110000011100100011001111110001110011111000000000000000000000000000100100110000001111110001110011111000000000001001000100010000000000001111100000111110001001000110001000111110000011110000000000000000010001001100111111000100111110011000000000000000000000000010000011000000000110010001100010000000000011111000001111000000000000000000111110001111000111110001111000001001001100111111000111001111100000000000100100111001111110001111001111100000000000000000000000111100000111001000111001111110001111001111100000000000000000000000000000001111000001110010010001000000000000000000000000111110000011111000100100

Try it online!

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

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

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

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

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

### Operation wheel commands

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

### Math wheel commands

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

See the language page for descriptions of unused commands

Try it online!

:| this is shorter than the all-caps no-punctuation one here (official website). is everyone bad at golfing or do i just have no life? also i have absolutely no clue how to contact the author

– ASCII-only – 2018-05-06T05:08:16.150

5

# Flobnar, 5342 41 bytes

-12 thanks to @JoKing

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

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

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

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

The relevant terms used by this program are:

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

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

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

A fascinating language. It took me a bit to figure out how to do basic looping, so I tried a get/put approach and only got it down to 58 bytes. Well done!

– Jo King – 2018-08-07T05:08:11.740

146 bytes – Jo King – 2018-08-07T05:24:43.600

@JoKing Nice! Very clever usage of the !. I hadn't thought of the use of _ as another way to discard the result of ,. – Esolanging Fruit – 2018-08-07T07:07:18.117

1

@JoKing I managed to get down to 45 bytes through some fairly drastic rearrangement of the code. The bytes needed to compute the 12 bother me, though -- maybe you can see something I didn't?

– Esolanging Fruit – 2018-08-07T07:12:54.873

1

All I could get was a different 45er

– Jo King – 2018-08-07T07:33:22.530

Going back to my old version, I got 42 bytes (i swear, the last character being printed was completely accidental)

– Jo King – 2018-08-07T08:17:08.903

@JoKing Even if it was an accident, that's very clever! I can't see this getting much shorter without a new approach so I'll edit that version into the answer. – Esolanging Fruit – 2018-08-07T20:32:22.653

Technically, if you use the -i flag to disregard invalid instructions you can save one byte by removing the # – Jo King – 2018-08-10T07:30:40.343

5

# whenyouaccidentallylose100endorsementsinnationstates -  900  761  728  552  260 bytes

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

Try it online!

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

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

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

Golfed down to 260 bytes with the help of @ASCII_only

I'm very curious as to what the inspiration for this languages name is. – Gabriel Mills – 2019-02-06T02:38:12.847

2

@GabrielMills Explained here to Dennis

– MilkyWay90 – 2019-02-06T02:42:26.283

5

# EBCDIC Punched Card, 13 bytes

Disk Operating System/360, also DOS/360, or simply DOS, is a discontinued operating system for IBM mainframes. It was announced by IBM on the last day of 1964, and it was first delivered in June 1966.In its time, DOS/360 was the most widely used operating system in the world.

A typical configuration might consist of a S/360 model 30 with 32KB memory and the decimal instruction set, an IBM 2540 card reader/card punch, an IBM 1403 printer, two or three IBM 2311 disks, two IBM 2415 magnetic tape drives, and the 1052-7 console.

5

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

Try it online!

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

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

5

# Cood, 378 bytes

I want 72 of this
Im very hungry
More 29 of this
Im very hungry
More 7 of this
Im very hungry
Im very hungry
More 3 of this
Im very hungry
Less 67 of this
Im very hungry
Less 12 of this
Im very hungry
More 55 of this
Im very hungry
More 24 of this
Im very hungry
More 3 of this
Im very hungry
Less 6 of this
Im very hungry
Less 8 of this
Im very hungry
Less 67 of this
Im hungry

Try it online!

378 bytes: Try it online!

– the default. – 2020-04-11T09:47:30.857

I do not even use the TIO front page most of the time: I simply type in something like tio.run/#cood – the default. – 2020-04-11T10:47:22.353

Ahh, I see. I don't know why it doesn't appear on the front page though. – None – 2020-04-11T10:48:26.370

It appears for me when I type Cood in the search bar. – the default. – 2020-04-11T10:52:05.863

5

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

1Can you put Integral on GitHub? – None – 2020-08-03T00:38:13.673

Also, how do loops work? I tried using e but it froze the interpreter. – Lyxal – 2020-08-03T00:38:46.393

@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 – 2020-08-03T12:59:47.680

@petStorm I haven't used GitHub yet, but I am working on it. – nph – 2020-08-03T13:04:57.197

1

@petStorm GitHub repository. For some reason the code is not working. For now keep using the old interpreter.

– nph – 2020-08-03T13:19:06.110

@nph Thanks a lot! (Because Google sites is inaccessible in my location) – None – 2020-08-03T13:24:31.897

@petStorm the GitHub html cannot render the symbols, so it is unusable. I don't know why. – nph – 2020-08-03T13:35:12.833

@petStorm The js does work. – nph – 2020-08-03T13:52:00.580

1

Anyway, I created a GitHub pages online interpreter.

– None – 2020-08-03T13:53:23.997

@petStorm Thank you! – nph – 2020-08-03T14:04:28.087

@petStorm Hi china person – null – 2020-08-15T12:08:08.363

@HighlyRadioactive Now I feel confident to put that in my location bar – None – 2020-08-15T12:24:48.660

@petStorm How to identify chinese 1. Can't access certain sites 2. Don't add spaces after puncuations. – null – 2020-08-15T12:32:54.733

5

# Prolog, 23 bytes

write('Hello, World!').

What did you use to define a string if you didn't use "? – Beta Decay – 2015-08-28T12:57:50.563

1@BetaDecay Nothing, strings didn't exist as far as I know. So using " to create strings would create an array of character codes (ie ascii/unicode codes) representing the string. Character codes strings is created with backquotes in SWI-Prolog now. – Fatalize – 2015-08-28T13:01:17.377

You can use single quotes to turn this into an atom, and thus make the program completely portable: write('Hello, World!'). More declaratively, I would simply define a a fact like: msg('Hello, World!').. Usage example: ?- msg(M)., succeeding with M = 'Hello, World!'.. – mat – 2015-09-01T12:18:46.163

@mat Good suggestion that I use atoms instead of strings. For the msg('Hello, World!') though, I don't think it's valid in this challenge because it outputs M = 'Hello, World!'. instead of just Hello, World! (granted, it also outputs true after in my answer but I assume this is acceptable because Prolog really likes to output true or false :)) – Fatalize – 2015-09-01T12:25:11.360

I know, the way this challenge is formulated kind of forces you to use impure langauge elements. Too bad! (BTW: The last sentence of your post is no longer applicable.) – mat – 2015-09-01T12:27:36.260

5

# J, 15 bytes

'Hello, World!'

No call to any write function needed.

5

# Forth, 17 bytes

.( Hello, World!)

." Hello World! is one byte shorter. – Lynn – 2015-08-28T20:27:32.150

1." may only be used within a function declaration. ." : error(-14): use only during compilation – mbomb007 – 2015-08-28T20:47:05.253

Why the space in .( Hello,? – Erik the Outgolfer – 2016-06-16T14:56:10.503

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Forth requires spaces between tokens. The ending ) is the exception to the rule. – mbomb007 – 2016-06-16T14:56:48.613

@mbomb007 It's unfair that ." is only in functions. – Erik the Outgolfer – 2016-06-16T15:03:12.907

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Same with loops. – mbomb007 – 2016-06-16T16:15:49.083

5

# Batch File, 19 Bytes

@echo Hello, World!

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

Example without the @

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

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

Isn't the language itself just called "Batch"? – mbomb007 – 2015-08-28T13:54:38.630

1

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

If you leave off the the echo you get an infinite amount of hello world!'s – User112638726 – 2015-08-28T14:21:23.723

@User112638726 No, you should get something like 'Hello' is not recognized as an internal or external command, operable program or batch file. If you get something else, you must be using a different version of the interpreter than I am. – AdmBorkBork – 2015-08-28T14:28:03.157

@TimmyD It does that if i type directly into CMD but if it is run as a .bat it loops forever. Weird. – User112638726 – 2015-08-28T14:50:19.553

@User112638726 I believe it. Using batch files with command-line interpretation in Windows is ... quirky, shall we say. Nevermind the differences between CMD.EXE and COMMAND.COM, let alone the spaghetti code hodge-podge that's resulted in changes from DOS to 9x to NT to XP to Vista+ ... It's a right mess ... And that's not even counting the OS/2 flavors, the 4DOS flavors, DR-DOS ... or the ridiculousness of the FOR command ... ugh. Best to just leave all that crud behind and move on.

Well User112... gave me an idea. Rename your batch file to Hello.cmd and call it via Hello and you can shave off some extra bytes: @echo %0, World! 16 bytes – MrPaulch – 2015-08-29T11:33:42.073

2@MrPaulch if the filename is significant it has to be added to the byte coutn – undergroundmonorail – 2015-08-30T23:01:53.043

5

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

5

# Bash, 18 bytes

echo Hello, World!

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

5

# Applescript, 15 bytes

"Hello, World!"

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

1It's nice to see these verbose languages -- Applescript, PHP, PowerShell, etc. -- getting the better of lots of other languages for once. :) – AdmBorkBork – 2015-08-28T15:53:08.113

@TimmyD That doesn't mean that they are good languages. It's just that they are better at some things. – galexite – 2015-08-28T16:53:45.420

1@georgeunix Oh, without a doubt. Every language has its pluses and minuses. There are plenty of things I'd change about PowerShell, but there's nothing else I'd rather use to script and config Exchange. Even if it had commands and functionality to do so, I don't think I could use Pyth or CJam or whatnot on a day-to-day basis instead. I was just meaning "It's nice to see non-golfing languages toward the top of the lowest-byte-count list for a change." – AdmBorkBork – 2015-08-28T17:06:16.680

I understand @TimmyD – galexite – 2015-08-28T17:07:11.810

5

# Julia, 22 bytes

print("Hello, World!")

Short and sweet.

5

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

5

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

5

# Inform 7 + C by G, 36 bytes

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

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

3I got rid of my old version. – Lynn – 2015-08-29T05:20:08.743

Please change the language name to "Inform 7 + C by G", since you're using a library – ASCII-only – 2018-04-20T01:22:57.040

@ASCII-only As the cost of the library is included I don't think that's necessary. – curiousdannii – 2018-04-20T01:34:41.460

@curiousdannii nope, it's still necessary (at least for libraries that don't come with the standard distribution) – ASCII-only – 2018-04-20T02:48:19.387

5

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

5

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

5

# NULL, 91 bytes

int("8bxyd2qvpj6uq6gh9u8hlrjfwqkx8i2pvid5auhrsrbpp8gsczv6ye26ew0pkx05wem94m9zqkn8prqir",36)

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

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

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

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

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

print - length / 25

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

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

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

5

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

1Nice, I didn't know about the parameters it takes :) – Lynn – 2015-09-03T02:00:43.093

5

# Jasmin, 251219 165 bytes

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

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

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

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

# 4 Years Later Golfs

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

# Non-competing golfs

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

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

5

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

5

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

5

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

5

# 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 – 2015-12-14T14:23:43.630

There was a suggestion on one of my other posts that suppressing STDOUT should have a cost, so I followed that here. But it doesn't seem to be consistently followed. – Dale Johnson – 2015-12-14T22:44:33.787

The convention is typically 1 byte / switch. However, you can raise the question on Meta and get the community's opinion.

– cat – 2015-12-14T22:56:07.557

5

# Wise, 135 + 3 = 138 bytes

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

Try it online!

4

## TP, 17,806 bytes

TP is a language I created based on using toilet paper.

The main operation is USE TP which removes a sheet (1) from the current roll (cell), each roll starts at 255 sheets. There is also GET TP which adds a new roll to the toilet paper pile. There is also the accompanying NEW TP and OLD TP which switches to a newer roll or older roll respectively. The final notable command is DIS TP which displays the ASCII value for the current roll.

This can definitely be shorter.

USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

The interpreter always removes whitespace from the working line, so USE TP becomes USETP, this allows a 1 byte decrease per line. Since the interpreter uses Python, I believe newline style (CR+LF, LF) doesn't matter. A thing that I'm trying to think of a way to do is add a separator (command; command). If I figure out a way to implement that, then the filesize can be drastically reduced.

Doing a quick estimate you can probably get this down to around 6500 bytes. I would write it up but I can't at the current time (if I get some time this weekend I'll run through it). – Teal pelican – 2016-11-18T16:00:02.330

6damn, that's a lot of trees cut down... – FlipTack – 2016-11-18T18:27:23.917

@Flp.Tkc Maybe I should make a version where you plant trees? – ender_scythe – 2016-11-18T18:33:59.767

Calculation for chars(6405 bytes)
H=(255-72)"USE TP "+"DIS TP "
e="GET TP NEW TP "(255-101)
"USE TP "+"DIS TP "
l="GET TP NEW TP "+(255-108)"USE TP "+"DIS TP "
l="DIS TP "
o="GET TP NEW TP "+(255-111)
"USE TP "+"DIS TP "
,="OLD TP OLD TP OLD TP "+(72-44)"USE TP "+"DIS TP "
=(44-32)
"USE TP "+"DIS TP "
W="NEW TP "+(101-87)"USE TP "+"DIS TP "
o="NEW TP NEW TP DIS TP "
r="GET TP NEW TP "+(255-114)
"USE TP "+"DIS TP "
l="OLD TP OLD TP DIS TP "
d=(108-100)"USE TP "+"DIS TP "
!="OLD TP "+(87-33)
"USE TP "+"DIS TP "
– Teal pelican – 2016-11-21T09:03:06.780

I messed up the formatting a little but the basic premise is using 5 TP's and just going to the nearest TP with more than we need the removing it from it. – Teal pelican – 2016-11-21T09:06:21.750

@Tealpelican That works? – ender_scythe – 2016-11-21T14:48:35.880

4

# uBASIC, 21 bytes

1PRINT"Hello, World!"

uBASIC is the most basic BASIC.

Exits with an error (no trailing newline).

It took me until just now to realize I don't need a space between 1 and PRINT...

Try it online!

4

# *><>, 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 – 2016-12-19T14:47:37.093

4

with Text_IO;procedure H is
begin
Text_IO.Put("Hello, World!");end;

Thanks to 3D1T0R and breadbox for improving this!

Try it online!

I'm not all that familiar with Ada, but took a swing at 'golf'ing this down a bit. Please evaluate: https://ideone.com/JjmhIt 75 bytes.

– 3D1T0R – 2018-05-29T19:31:42.633

1Also note that the Ada. can be dropped (both places) to save 8 bytes. – breadbox – 2018-05-29T21:20:08.937

1Wow, somebody replied to this over a year later! You can combine 3D1T0R's golf with breadbox's tip to golf it down quite a bit. – python-b5 – 2018-05-30T20:25:57.690

@breadbox: I could have sworn I tried that, but apparently not. I kind of doubt this can be golfed much more. – 3D1T0R – 2018-05-31T21:22:48.153

TIO link pls – ASCII-only – 2018-12-26T01:02:52.070

4

# No, 1185 bytes

NOOOOOOOOOOOOOOO?Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooo
NOOOOOOOO?yes

Try it online!

No is a line based language, meaning that execution starts on the last line and the other lines are referenced throughout the program. Each line consists of the following:

• A command, in the format of N followed by a number of Os. The number of Os determines which command is meant
• One or more arguments, separated from the command with a ? and from each other with a !. The arguments can be one of four options:
• N followed by $$\n\$$ os. This represents a character with charcode $$\n\$$
• n followed by $$\n\$$ os. This represents an integer $$\n\$$
• $$\m\$$ ns followed by $$\n\$$ .s and $$\p\$$ Os. This represents a floating point number with integer part $$\m\$$ and a fraction part consisting of $$\n\$$ $$\0\$$s followed by $$\p\$$. For example, nnn.O is $$\3.01\$$
• ye followed by $$\n\$$ ss. This references the result found by running line $$\n\$$, 1-indexed.

This Hello, World program works by first running the last line:

NOOOOOOOO?yes

8 Os means that this is the output command, so this line outputs the value of line 1, the super long one. Line 1 works by using the „string builder“ command (NOOOOOOOOOOOOOOO or 15 Os) which takes a list of characters and returns them joined as a string. In this case, the characters form the String Hello, World! and so use the charcodes of those letters in order to return characters according to the 1st type of argument as specified above.

"Don't ask. Just read the GitHub page." I can't, it's a 404. There's not even an archive. So I ask: WHAT?!? – Fabian Röling – 2020-07-14T10:13:46.243

1@FabianRöling Thanks for letting me know! This answer‘s actually out of date, so I‘ve updated it, including the link to the Github page – caird coinheringaahing – 2020-07-14T10:20:58.600

I guess I could now first learn Python, then analyse the source code of the interpreter, then based on that analyse your source code… But maybe you can explain it easier? :) – Fabian Röling – 2020-07-14T11:09:15.390

@FabianRöling Yeah sure, I‘ll edit in an explanation now – caird coinheringaahing – 2020-07-14T11:09:51.773

The program sounds like a person being outgolfed. – null – 2020-08-03T01:14:38.657

@cairdcoinheringaahing More like, "Thanks for letting me no!" – Calculuswhiz – 2020-08-03T13:59:17.160

4

# OIL, 15 bytes

Hello, World!
4

OIL is a self-modifying turing-machine-like programming language with random access, and weak typing. The first line does nothing, because it's not one of the integers currently defined as commands, so it is just skipped. The second line is a 4, the print command, which takes one argument (the next line) and prints the value at that location. Since the next line doesn't exist, it's uninitialized and defaults to 0, which causes OIL to print the contents of the 0th line, Hello, World!.

4

# Klein, 50 + 6 = 56 bytes

+3 bytes due to the -A flag.

+3 bytes for 000 topology (though in my testing, pretty much all valid topoligies work)

89*45:**:(1+:7+::3+:(492+*84*9:*6+):3+6:3**)84*1+@

(Eligible for the bounty) Probably not optimal, but it's a start.

You do have to add 3 for the topology you are using and 3 for the -A flag, (but so does everyone else, so it shouldn't hurt you) – Wheat Wizard – 2017-05-18T19:09:50.863

@WheatWizard Yep, just added that in. – Okx – 2017-05-18T19:11:13.953

@WheatWizard It appears to work with an empty argument as well. https://tio.run/##DcgxEoAgEAPA70AyFsiJkEofY@Ho@P8usuU@73V/dh@ITYBSoXZKlUoxVqIHhtCYZzVVIM8pPGwvp38

– Dennis – 2017-05-19T00:58:41.440

@Dennis Would that be +2 bytes then? – Okx – 2017-05-19T06:15:54.443

Could you make the title Klein, 50 + 6 = 56 bytes as it kinda messes up the catalogue? – caird coinheringaahing – 2017-05-22T14:39:48.343

@RandomUser Sure thing. – Okx – 2017-05-22T15:38:18.773

4

# Klein, 48 + 3 + 3 = 54 bytes

89*55+:*:(1+:7+:::(3+:(485*+48*699*+):3+))148*+@

Try it online!

4

# COBOL, 65 Bytes

PROGRAM-ID.H.PROCEDURE DIVISION.DISPLAY 'Hello, World!'.STOP RUN.

Just from what I remember. Probably doesn't work but I can't tell since my machines set up to run COBOL are long-gone.

2Welcome to the site! – James – 2017-05-25T15:39:35.400

This works just fine with GNU COBOL assuming you set the -F (or -free) flag, but you're missing a comma in your string. https://tio.run/##S85Pys/RTc8r/f8/IMjfPcjRV9fTRc9DD8hxdnUJDXJVcPEM8wz29PfTc/EMDvBxjFRQ90jNycnXUQjPL8pJUVTX@///X3JaTmJ68X9dNwA

– Dennis – 2017-07-17T20:52:06.373

So I am. I shall fix this. – Bakna – 2017-07-17T20:53:08.550

You can save 10 bytes: PROGRAM-ID.H.PROCEDURE DIVISION.DISPLAY'Hello, World!'. – SirBogman – 2020-07-21T22:03:50.363

4

# Memescript, 820 bytes

what the frick frack backtrack snick snack quarterback diddily dack diddily dack quarterback diddily dack diddily dack backtrack diddily dack backtrack diddily dack biofeedback quarterback diddily dack diddily dack quarterback quarterback diddily dack quarterback diddily dack diddily dack patty wack quarterback diddily dack slack mack frick frack thumbtack snick snack snick snack quarterback diddily dack patty wack sidetrack quarterback diddily dack snick snack patty wack patty wack biofeedback quarterback diddily dack diddily dack sidetrack diddily dack sidetrack quarterback diddily dack diddily dack patty wack quarterback diddily dack patty wack slack mack quarterback diddily dack patty wack crackerjack quarterback diddily dack slack mack frick frack thumbtack snick snack patty wack quarterback diddily dack

Explanation:

what the                     open program
frick frack backtrack        push 10
snick snack quarterback      multiply by 7 (70)
diddily dack diddily dack    add 2 (72)
quarterback diddily dack     print as char ('H')
diddily dack backtrack       add 10 (82)
diddily dack backtrack       add 10 (92)
diddily dack biofeedback     add 9 (101)
quarterback diddily dack     print as char ('e')
diddily dack quarterback     add 7 (108)
quarterback diddily dack     print as char ('l')
quarterback diddily dack     print as char ('l')
diddily dack patty wack      add 3 (111)
quarterback diddily dack     print as char ('o')
slack mack                   pop
frick frack thumbtack        push 11
snick snack snick snack      multiply by 4 (44)
quarterback diddily dack     print as char (',')
patty wack sidetrack         subtract 12 (32)
quarterback diddily dack     print as char (' ')
snick snack patty wack       multiply by 3 (96)
patty wack biofeedback       subtract 9 (87)
quarterback diddily dack     print as char ('W')
diddily dack sidetrack       add 12 (99)
diddily dack sidetrack       add 12 (111)
quarterback diddily dack     print as char ('o')
diddily dack patty wack      add 3 (114)
quarterback diddily dack     print as char ('r')
patty wack slack mack        subtract 6 (108)
quarterback diddily dack     print as char ('l')
patty wack crackerjack       subtract 8 (100)
quarterback diddily dack     print as char ('d')
slack mack                   pop
frick frack thumbtack        push 11
snick snack patty wack       multiply by 3 (33)
quarterback diddily dack     print as char ('!')

4

# Triangular, 66 bytes

8.9,*<>@5\,1*6<>-+@7\,+3@@+<>@:3_7+\,3@-*43@<>*9-@p@3+\@_3@-8@-6@<

Try it online!

## How it works

Expanded:

8
. 9
, * <
> @ 5 \
, 1 * 6 <
> - + @ 7 \
, + 3 @ @ + <
> @ : 3 _ 7 + \
, 3 @ - * 4 3 @ <
> * 9 - @ p @ 3 + \
@ _ 3 @ - 8 @ - 6 @ <

Executed commands, ignoring directional commands:

89*@56*1-+@7+@@3+@:3_7+@4*-@3*9-@p@3+@6-@8-@3_@

Commands used, ignoring directional commands:

• 1 to 9: push the literal value
• -: subtract
• *: multiply
• _: divide
• :: duplicate top of stack
• p: pop top of stack
• @: print top of stack as charcode

Triangular is a 2D stack-based language which uses postfix notation.

4

# Plain English901 308 bytes:

To run:
Start up.
Put "Hello, World!" in a b buffer.
Call "kernel32.dll" "GetStdHandle" with -11 returning a h number.
Call "kernel32.dll" "WriteFile" with the h
and the b's first and the b's length
and a r number's whereabouts and 0 returning the r.
Call "kernel32.dll" "CloseHandle" with the h.
Shut down.

ungolfed, with comments and error traps:

To run:
Start up.
Put "Hello, World!" in a buffer.
Write the buffer to stdout.
Shut down.

To write a buffer to stdout:
Clear the i/o error.
Get stdout returning a standard handle.
If the i/o error is not blank, exit.
Call "kernel32.dll" "WriteFile" with the standard handle
and the buffer's first and the buffer's length
and a number's whereabouts and 0 returning the number.
Call "kernel32.dll" "CloseHandle" with the standard handle.
If the number is not 0, exit.
Put "Error writing to the standard error stream." into the i/o error.

To get stdout returning a standard handle:
\ std_input_handle = -10; std_output_handle = -11
Call "kernel32.dll" "GetStdHandle"
with -11 [std_output_handle]
returning the standard handle.
If the standard handle is -1 [invalid_handle_value],
put "Error opening the standard output stream." into the i/o error; exit.

The Plain English IDE is available at github.com/Folds/english. The IDE runs on Windows. It compiles to 32-bit x86 code.

Write a buffer to stdout and Get stdout returning a standard handle seem like good candidates for adding to Plain English's library. Similar routines already exist for stderr.

Seems like a very interesting language, but very verbose. Wow! – Neil A. – 2017-06-28T06:35:40.260

Is there a character I am missing? It shows up as 307/899 bytes for me, respectively – Neil A. – 2017-06-28T06:37:00.590

@NeilA. - Your counts are probably correct. I estimated the byte counts by adding up the (1-based) indexes of the character positions after the last character on each line. It is likely that this process resulted in an extra character being counted after the last line. This process also assumes that the lines can be separated using one byte (such as a space or line feed) instead of the actual two-byte CRLF that is used when the editor saves the file. But since Plain English is designed to successfully compile the file if the CRLFs were replaced by spaces, the latter issue is not a problem. – Jasper – 2017-06-28T15:45:18.097

@NeilA. -- My first stab at the problem was much shorter (about 76 bytes), but it launched a complete CGI environment and output to that environment's stdout. This version outputs in the stdout that the user starts in. If I make Plain English treat stdout as nicely as it treats stderr, this version can be shortened to about 88 bytes. – Jasper – 2017-06-28T15:55:25.667

@programmer5000 -- According to the rules of this challenge, "The program must not write anything to STDERR." – Jasper – 2017-07-19T15:28:54.230

4

## Sqirrel - Peter, 903 bytes

A couple notes about my golfing:

• The examples have punctuation at the end of sentences but the spec doesn't say that it should be there so I left it off.
• The spec says The request consists firstly of the text "I wish I had a " then is followed by a thing. and list of the variable-things you can use: ... an Apple which is inconsistent so I used "I wish I had a Apple" because it is shorter.
• The spec says Here is [nr] [thing][s] Set the var to NR. Add an 's' if needed and even though the examples use Fishes the only ones that should be valid are Fish and Fishs and I chose Fish because I don't think it needs to be plural and it is shorter.
• There is an exit command but the spec doesn't say what happens if the flow reaches the end of the text so I am assuming the program ends and I didn't use the exit command.

Here is my attempt:

I wish I had a Fish
Here is 72 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 101 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Apple
Here is 108 Apples
I wish I had a Apple
Now everyone has it
I wish I had a Apple
Now everyone has it
I wish I had a Forrest
Here is 111 Forrests
I wish I had a Forrest
Now everyone has it
I wish I had a Fish
Here is 44 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 32 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 87 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Forrest
Now everyone has it
I wish I had a Fish
Here is 114 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Apple
Now everyone has it
I wish I had a Fish
Here is 100 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 33 Fish
I wish I had a Fish
Now everyone has it

If I count correctly, that's 66 more bytes for the version with correct punctuation and grammar. I.e. an apple, 100 fishes, etc. and a dot at the end of each line. – Cœur – 2017-08-24T13:15:00.493

4

# ,,,, 14 bytes

"Hello, World!

I finally added unclosed strings to ,,,. Took me long enough.

4

## ZT, 199 bytes

The ZT programming language is quite romantic: it features little data couples (Romeos & Juliets). ZT program flow is diagonal and commands are defined only by program flow.

The webpage is at:

It has a link to is an interpreter at:

But that interpreter is broken and doesn't do jumps correctly. The website also has a link to a self extracting archive containing the documentation, the interpreter and some examples:

And that interpreter works so that's the one you need to use to test this.

I am not too confident that this is the smallest possible Hello World but it is much smaller than the one published on the website. If you have comments for golfing it please let me know.

48<>ZT<>ZT<>...>
<<ZT<>ZT<>ZT.<06
ZT<>ZT<>6F<>6C<<
<<ZT<>ZT<>ZT><03
ZT<>ZT<>20<>72<<
<>ZT<>ZT<>ZT><05
...>65<>6F<>57<<
.>ZT<>ZT<>ZT><05
....64<>6C<>2C<<
....<>ZT<>ZT><05
........21>.6C<
........<...>

4

# Numberwang, 77 bytes

69696969696969693696969623673363316969696968359533059595636969663633563583193

Try it online!

Just incrementing and decrementing the pointer by certain amounts.

Brainfuck translation, 72 – ASCII-only – 2018-04-14T07:36:40.937

4

;I-      &  e$& m- & g2Ph$      &  a2$& n$      &  e2+-      &  g2Ph$& OPh$      &  m-      &  e-      &  n-
}     AgR};      AgR};      A=AgR};         AgR};       AgR};      AgR};        AgR};         AgR};        AgR};      AgR};      AgR};      AC

Try it online!

db 0x55
db 0xAA

## Running

The code can be runned with QEMU using the following command, assuming the binary code is saved in a file called hello.bin:

qemu-system-x86_64 -drive format=raw,file=hello.bin

Can you assume that regs like cx are already cleared? – ceilingcat – 2019-05-07T05:32:04.070

4

# Keg, 15 8 bytes

«H%c¡|,!

Try it online!

Wow. It's been a while since I posted this. And boy oh boy how Keg has changed.

### Explained

« #Start a special compressed string
H% #String compression code (SCC) for "Hello"
c¡ #SCC for "World"
|,! #Join "Hello" and "World" with a , and ! to create "Hello, World!"
« #Close the special compressed string and implicitly print

## Old Program

Hello\, World\!

Keg is a newly created stack-based, golfing language, which focuses on only having symbols as functions and keywords. As such, alphanumeric characters are pushed to the stack as letters (even spaces are pushed, meaning that they aren't NOPs).

Symbols that would normally be commands can be escaped using \'s.

4

# axo, 22 bytes

"!dlroW ,olleH"[>[(#<\

Try it online!

Pushes "Hello, World!" to the stack "!dlroW ,olleH"

Duplicates top of stack afterward, which results in "HHello, World!" [

Moves to the right >.

Duplicates it again, which results in "HHHello, World!" [

Outputs "H" while popping from the stack, so the stack is "HHello, World!" (

Pops the top of the stack, results in "Hello, World!" #

Moves left <

Pops the top of the stack, results in "ello, World!" #

Outputs "e" while popping from the stack, which results in STDOUT being "He" and the stack being "llo, World!" (

Duplicates the top of the stack, resulting in the stack being "lllo, World!" [

Moves right. >

And I'm sure you can figure out the rest. If you can't, I'll update a more indepth-explanation soon.

4

# A Pear Tree, 25 bytes

print'Hello, World!'#»G²Ú

Try it online!

A Pear Tree programs are written in an arbitrary ASCII-consistent 8-bit character set; for codepoint 128 and above, the interpreter cares about the codepoint numerically, not the represented character. TIO uses Latin-1, so the above program is actually a Latin-1 decoding of the codepoints that make it up.

## Explanation

print'Hello, World!' should be fairly self-explanatory. However, there is some choice available here; print"Hello, World!" would have been the same length, but leads to the resulting checksum being less printable.

The checksum is the interesting part of the program. In this program, that's the #»G²Ú at the end. For golfing, you'd want the shortest workable checksum, which is normally 4 or 5 bytes long. (It's a 32-bit checksum, so 4 bytes would normally be enough, but the checksum is also executed as code, and thus needs to be a valid command; the # starts a comment, so # plus 4 bytes is normally enough to add a checksum to anything.) The checksum doesn't have to cover the whole code, but does have to cover a prefix of the part of the code that actually runs; adding comments at the end is terser than adding them at the start, and we want to execute the entire program, so for this program, I caused the checksum to cover the entire program.

Although a Hello World program doesn't benefit much from the checksumming, we could have made use of the checksum behaviour to embed the Hello World program into a larger document or write multiple copies of the program so that if one gets corrupted, the others can still run. This makes A Pear Tree considerably more robust than most languages are.

4

# strict, 18 bytes

out: Hello, World!

Believe it or not, the space is required (hence the language name). In case the website dies, here's the interpreter download link.

4

# Triangular, 55 bytes

6\6+@*8\C::6--::@\@#2"+3^82*@3/#-<*#+/@"#+F<3/3@@#-7:*<

This one took a while. Also will be very difficult to golf, since there is zero no-ops in it, meaning you'll have to save 10 bytes to get it to a size 9 triangle in order to save any bytes

This expands out into this size 10 triangle:

6
\ 6
+ @ *
8 \ C :
: 6 - - :
: @ \ @ # 2
" + 3 ^ 8 2 *
@ 3 / # - < * #
+ / @ " # + F < 3
/ 3 @ @ # - 7 : * <

# How it works

Note: this ignores all control flow characters and just looks at what gets run in order

66* Push 36
:: Duplicate it twice
2*# Output H, popping it
3*  Multiplies by 3, yielding 108
:   Duplicates
-7# Outputs e, popping it
@@  Outputs l twice, without popping it
3+@ Outputs o, without popping it
" Swaps, putting 36 at the top of the stack
:: Duplicates it twice
8+@  Outputs comma, without popping
C-#  Outputs space, popping the top of the stack
2*F+# Outputs W, popping it
"     Swaps back around, putting 111 at the top of the stack
@     Outputs o, without popping
3+@   Outputs r, without popping
6-@   Outputs l, without popping
8-#   Outputs d, whilst popping
3-@   Subtracts 3 from 36, giving !, and outputs it
6     Pushes 6, which does nothing

Try it Online!

Rearranging the structure, I can get you 3 no-ops, though really it's only one byte TIO. Only 7 more to go!

– Jo King – 2019-08-25T21:40:20.577

2 more. Halfway there. – Jo King – 2019-08-25T21:50:06.380

Ok, I've got all the characters onto the stack in a size 9 triangle, but I dont have any space to put a loop to print all of them. Maybe could be golfed slightly more to fit it in TIO

– EdgyNerd – 2019-08-26T06:10:27.463

4

## Pxem, 0+17=17 bytes

Using the filename as data without counting the length is cheating. Therefore it is 17 bytes. (It even uses the filename extension as part of the program!)

Save the program as

Hello, World!.pxe

and the file contents should be empty.

You know, just testing Feeds... – None – 2020-01-10T04:07:57.990

4

# Verbosity v2, 152 bytes

IncludeTypePackage<OutputSystem>
IncludeTypePackage<StringArray>
outpu=OutputSystem:NewOutput<DEFAULT>
OutputSystem:DisplayAsText<outpu;"Hello, World!">

Try it online!

Introducing Verbosity v2! This is a short as it gets, as variable names must be 5 characters or more. The ungolfed version isn't much different:

IncludeTypePackage<OutputSystem>
IncludeTypePackage<StringArray>

output = OutputSystem:NewOutput<DEFAULT>

OutputSystem:DisplayAsText<output; "Hello, World!">

Try it online!

And it's pretty obvious how it works.

4

# International Phonetic Esoteric Language, 16 bytes

"Hello, World!"o

"Hello, World!"  (push "Hello, World!")
o (pop and print)

4

# Poetic, 324 bytes

the i/o case of HELLO
a good i/o drill is:say a HELLO
i said HELLO,saying it in Poetic
i code in Poetic,a good way to write a poem
a special piece for you
a special piece in machine writing for you
i already think i do pretty well writing for the machine poem
Poetic program syntax is nice
a perfect sorta poem and a program

Try it online!

This is nothing original, it's a straight port of the brilliant brainfuck answer from @KSab...but it turns out that it's the shortest representation of Hello, World! that I can find in Poetic. If anyone can golf this, please let me know; I'm definitely interested if someone can beat this solution!

4

# Intcode, 201 bytes

72,4,0,-1,1101,1,100,3,4,3,1101,100,8,3,4,3,4,3,1101,100,11,3,4,3,1101,40,4,3,4,3,1101,30,2,3,4,3,1101,80,7,3,4,3,1101,100,11,3,4,3,1101,100,14,3,4,3,1101,100,8,3,4,3,1101,98,2,3,4,3,1101,30,3,3,4,3,99

And this kids is why we don't golf using languages made up for programming competitions.

mmm undefined behavior – Unrelated String – 2019-12-05T06:31:10.160

Invalid opcodes are just NOPs in my interpreter – Lyxal – 2019-12-05T06:33:57.633

@UnrelatedString I mean, they haven't said what to do with undefined ops – Lyxal – 2019-12-05T06:34:21.327

Outgolfed – pppery – 2019-12-27T02:19:11.703

4

# naz, 64 bytes

9a8m1o3d4m5a1o7a2o3a1o3d7a1o9s3s1o3m9s1o9a9a6a1o3a1o6s1o8s1o3d1o

naz is my new language where every command is given by a number and a letter. Programs operate on a single register whose value can be between -127 and 127, inclusive.

This program uses the instructions for add, subtract, multiply, and divide to set the register to the ASCII value of each character in the string Hello, World!, then outputs that character with the o instruction. In the case of the Ls in Hello, once the register is set to the correct value, 2o is used to output twice instead of just once.

3Welcome to the site :) – FlipTack – 2020-01-01T11:57:37.097

4

# vJASS, 81 bytes

//! inject main
call BJDebugMsg("Hello, World!")
//! dovjassinit
//! endinject

This language is a scripting language for Warcraft 3.

Explanation:

• //! inject main injects function main takes nothing returns nothing.
• BJDebugMsg("Hello, World!") prints text on your in-game screen.
• //! dovjassinit is required for code injection.
• //! endinject injects endfunction

4

## Tetr4phobi4, 454 bytes

4OUR
fuor
fuor
4OUR
4OUR
4444
FO44
4OUR
4OUR
4OUR
4OUR
4OUR
fuor
4OUR
4OUR
4OUR
4OUR
4OUR
fuor
4OUR
four
4444
fuor
4OUR
4OUR
4OUR
4OUR
4OUR
4OUR
4OUR
four
4444
4444
fuor
4OUR
4OUR
4OUR
four
4444
FO44
4OUR
4OUR
4OUR
fuor
FOU4
4444
ffff
4OUR
4OUR
fuor
4444
FO44
4OUR
4OUR
4OUR
4OUR
4OUR
fuor
4OUR
4OUR
fuor
FOU4
four
4444
4OUR
4OUR
4OUR
4OUR
4OUR
4OUR
4444
4OUR
fuor
FOU4
four
4444
FOU4
FOU4
fuor
4OUR
4OUR
four
4444
FOU4
FOU4
4444
44UR
fuor
4OUR
four
4444

Ungolfed Code:

{44} H -> 72
4OURfuorfuor4OUR4OUR      {44} CELL[1] + 4 * 4 * 4 + 4 + 4
4444                                      {44} Print CELL[1]
FO44                                      {44} Next Cell

{44} e -> 101
4OUR4OUR4OUR4OUR4OUR      {44} CELL[2] + 4 + 4 + 4 + 4 + 4
fuor4OUR4OUR4OUR4OUR      {44} CELL[2] * 4 + 4 + 4 + 4 + 4
4OURfuor4OURfour              {44} CELL[2] + 4 * 4 + 4 / 4
4444                                      {44} Print CELL[2]

{44} l -> 108
fuor4OUR4OUR4OUR4OUR      {44} CELL[2] * 4 + 4 + 4 + 4 + 4
4OUR4OUR4OURfour              {44} CELL[2] + 4 + 4 + 4 / 4
44444444                              {44} Print CELL[2] twice

{44} o -> 111
fuor4OUR4OUR4OURfour      {44} CELL[2] * 4 + 4 + 4 + 4 / 4
4444                                      {44} Print CELL[2]
FO44                                      {44} Next Cell

{44} , -> 44
4OUR4OUR4OURfuorFOU4      {44} CELL[3] + 4 + 4 + 4 * 4 - 4
4444                                      {44} Print CELL[3]

{44} Whitespace -> 32
ffff                                      {44} Reset CELL[3]
4OUR4OURfuor                      {44} CELL[3] + 4 + 4 * 4
4444                                      {44} Print CELL[3]
FO44                                      {44} Next Cell

{44} W -> 87
4OUR4OUR4OUR4OUR4OUR      {44} CELL[4] + 4 + 4 + 4 + 4 + 4
fuor4OUR4OURfuorFOU4      {44} CELL[4] * 4 + 4 + 4 * 4 - 4
four                                      {44} CELL[4] / 4
4444                                      {44} Print CELL[4]

{44} o -> 111
4OUR4OUR4OUR4OUR4OUR      {44} CELL[4] + 4 + 4 + 4 + 4 + 4
4OUR                                      {44} CELL[4] + 4
4444                                      {44} Print CELL[4]

{44} r -> 114
4OURfuorFOU4four              {44} CELL[4] + 4 * 4 - 4 / 4
4444                                      {44} Print CELL[4]

{44} l -> 108
FOU4FOU4fuor4OUR4OUR      {44} CELL[4] - 4 - 4 * 4 + 4 + 4
four                                      {44} CELL[4] / 4
4444                                      {44} Print CELL[4]

{44} d -> 100
FOU4FOU4                              {44} CELL[4] - 4 - 4
4444                                      {44} Print CELL[4]
44UR                                      {44} Prev Cell

{44} ! -> 33
fuor4OURfour                      {44} CELL[3] * 4 + 4 / 4
4444                                      {44} Print CELL[3]

Try it online!

4

# Mornington Crescent, 3328 3271 bytes

Take Northern Line to Leicester Square
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Central Line to Holborn
Take Central Line to Bank
Take District Line to Hammersmith
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Bow Road
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Parsons Green
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Gunnersbury
Take District Line to Barking
Take District Line to Acton Town
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Elm Park
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminal 5
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Plaistow
Take District Line to Hammersmith
Take District Line to Gunnersbury
Take District Line to Mile End
Take District Line to Elm Park
Take District Line to Mile End
Take Hammersmith & City Line to Barking
Take Hammersmith & City Line to Paddington
Take Bakerloo Line to Piccadilly Circus
Take Bakerloo Line to Piccadilly Circus
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Westminster
Take District Line to Gunnersbury
Take District Line to Bow Road
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Gunnersbury
Take Circle Line to Aldgate
Take Metropolitan Line to Chorleywood
Take Metropolitan Line to Aldgate
Take Circle Line to Aldgate
Take Circle Line to Bank
Take District Line to Bow Road
Take District Line to Hammersmith
Take District Line to Gunnersbury
Take District Line to Plaistow
Take District Line to Gunnersbury
Take District Line to Mile End
Take Hammersmith & City Line to Paddington
Take Circle Line to Hammersmith
Take District Line to Mile End
Take District Line to Bow Road
Take District Line to Mile End
Take Hammersmith & City Line to Paddington
Take Bakerloo Line to Charing Cross
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Try it online!

-57 bytes by using shorter lines and transfer stations

Short explanation: I extract following strings:

Heathrow Terminals 1, 2, 3 (also extracting the numbers for some operations)
--                     --

---

Westminster
-

Chorleywood
---     -

The strings are cut in pieces, using the left and right substring functions of Gunnersbury and Mile End with the integers of "Heathrow Terminals 1, 2, 3" and "Heathrow Terminal 5" (which can be extracted using Parsons Green).

Then I concatenate them in Paddington and append a "!" by using the char code of (space)+1.

Source:

// ### Milestone: Extract "He", 1, 2, ", " from "Heathrow Terminals 1, 2, 3"

// Get "Heathrow Terminals 1, 2, 3"
Take Northern Line to Leicester Square
Take Piccadilly Line to Heathrow Terminals 1, 2, 3

// Copy that string
Take Central Line to Holborn
Take Central Line to Bank // Hammersmith = "Heathrow Terminals 1, 2, 3"

// Prepare for left substring
Take District Line to Hammersmith
Take District Line to Gunnersbury // Gunnersbury = "Heathrow Terminals 1, 2, 3"

// Extract 1 from "Heathrow Terminals 1, 2, 3"
Take District Line to Hammersmith
Take District Line to Parsons Green // Acc = 1, Parsons Green = ", 2, 3"

// Copy and store it somewhere (Parsons Green only returns its stored value if it gets a number)
Take District Line to Bank // Hammersmith = 1
Take District Line to Hammersmith

// Store it in Upminster for later calculations
Take District Line to Hammersmith
Take District Line to Upminster

// Store 2
Take District Line to Hammersmith
Take District Line to Parsons Green // Acc = ", 2, 3"
Take District Line to Parsons Green // Acc = 2, Parsons Green = ", 3"

// Get "He"
Take District Line to Gunnersbury

// Store it in Paddington for concatenation

// Extract ", " from ", 3"
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Gunnersbury // 2 was still stored in Gunnersbury

// Store it somewhere
Take District Line to Barking // Barking = ", "

// ### Milestone: Extract "llo" from "Holloway Road"

Take District Line to Acton Town

// Prepare for left substring
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Gunnersbury // Gunnersbury = "Holloway Road"

// Store 3
Take District Line to Hammersmith
Take District Line to Parsons Green // Acc = 3
Take District Line to Elm Park // Elm Park = 3

// Get 5 from "Heathrow Terminal 5"
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminal 5
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green // Acc = 5

// Copy and Store it somewhere
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Plaistow // Plaistow = 5

// Get "Hollo" from "Holloway Road"
Take District Line to Hammersmith
Take District Line to Gunnersbury // Gunnersbury = 5

// Prepare for right substring
Take District Line to Mile End // Mile End = "Hollo"

// Get "llo" from "Hollo"
Take District Line to Elm Park
Take District Line to Mile End

// Append it to "He"

// Append ", "
Take Hammersmith & City Line to Barking
Take Hammersmith & City Line to Paddington
Take Circle Line to Paddington // Paddington = "Hello, ", Acc = ", Hello, "

// ### Milestone: Get "!" by adding 1 to char value of " "
// Reverse acc
Take Bakerloo Line to Piccadilly Circus
Take Bakerloo Line to Piccadilly Circus
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Turnpike Lane

// Get ASCII value of " "
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross // Acc = 32

Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Upminster // 1 was stored in Upminster earlier
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross // Charing Cross = 33

// ### Milestone: Append "W" from "Westminster"
// Get "Westminster"
Take Northern Line to Bank
Take Circle Line to Westminster

// Get "W"
Take District Line to Gunnersbury // Gunnersbury = "Westminster"
Take District Line to Bow Road
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Gunnersbury

// Append it to "Hello, "

// ### Milestone: Append "orl" and "d" from "Chorleywood"
// Get "Chorleywood"
Take Circle Line to Aldgate
Take Metropolitan Line to Chorleywood

// Save it for copy
Take Metropolitan Line to Aldgate
Take Circle Line to Aldgate
Take Circle Line to Bank

// Bank had 1 in it, so save it for later
Take District Line to Bow Road

// prepare left substring
Take District Line to Hammersmith
Take District Line to Gunnersbury

// get "Chorl"
Take District Line to Plaistow
Take District Line to Gunnersbury

// get "orl"
Take District Line to Mile End // 3 is still stored in Mile End

// append it to "Hello, W"
Take Hammersmith & City Line to Paddington

// get "d"
Take Circle Line to Hammersmith
Take District Line to Mile End
Take District Line to Bow Road
Take District Line to Mile End

// append it to "Hello, Worl"
Take Hammersmith & City Line to Paddington

// get "!" and append it to "Hello, World"
Take Bakerloo Line to Charing Cross

// go home
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

4

# Length, 1071 bytes

Somebody once told me the
world is
gonna roll m
e. I ain't the sharpest t
o
ol in the\
shed. She was lookin
kinda dumb w
ith her finger a
nd her thumb in the shape
of an L on her forehead. Well
the years\
start coming
and they don't s
top coming... fed to the\
rules a
nd I hit t
he ground ru
nning. Didnt
make sense not t
o live for fun.\
t y
ets dumb. So muc
h to do, so much to see,\
so what's w
rong with taking the back
stre
ets? You never know\
if you don't
go. You neve
r shine if you d
on't glow. Hey now, your'
e an all sta
r, get your
game on, go play
. Hey now, y
our'e a ro
ckstar, get the show on,\
g
et paid. Al
l that glitt
ers is gold. Onl
y shooting stars break th
e mould. It's a cool pla
ce and the
y say it get
s colder. You're
bundled up now, wait till
you
get older.
But the medi
a men beg to dif
fer, judging by the hole\
in the
satellite p
icture. The\
ice we skate is\
getting pretty thin. The\
water's\
getting war
m, so you might\
as well swim. My world's\
on fire, how about yours? Thats t
he way I like it

There's an interpreter, but there's no permalink

Length is a newly created esolang by esolang.org user Nailuj29, so I thought I'd give it a go and write a HW program hopefully shorter than the example one. Spoiler: this is 42 bytes shorter. The commands are decoded based on the number of characters in each line.

And yes, I did use the lyrics to All Star by Smash Mouth.

## Explained

push 8
dup
push 1
mul
dup
outa
push 29
dup
outa
push 7
dup
dup
outa
outa
push 3
outa
push 11
push 4
mul
dup
dup
outa
push 12
sub
outa
dup
push 1
sub
dup
outa
push 24
dup
outa
push 3
dup
outa
push 6
sub
dup
outa
push 8
sub
outa
push 33
outa

### debug logs

1
push
----------
[8]
3
dup
----------
[8,8]
4
push
----------
[8,8,1]
6
----------
[8,9]
7
mul
----------
[72]
8
dup
----------
[72,72]
9
outa:::::::::
H----------
[72]
10
push
----------
[72,29]
12
----------
[101]
13
dup
----------
[101,101]
14
outa:::::::::
e----------
[101]
15
push
----------
[101,7]
17
----------
[108]
18
dup
----------
[108,108]
19
dup
----------
[108,108,108]
20
outa:::::::::
l----------
[108,108]
21
outa:::::::::
l----------
[108]
22
push
----------
[108,3]
24
----------
[111]
25
outa:::::::::
o----------
[]
26
push
----------
[11]
28
push
----------
[11,4]
30
mul
----------
[44]
31
dup
----------
[44,44]
32
dup
----------
[44,44,44]
33
outa:::::::::
,----------
[44,44]
34
push
----------
[44,44,12]
36
sub
----------
[44,32]
37
outa:::::::::
----------
[44]
38
dup
----------
[44,44]
39
----------
[88]
40
push
----------
[88,1]
42
sub
----------
[87]
43
dup
----------
[87,87]
44
outa:::::::::
W----------
[87]
45
push
----------
[87,24]
47
----------
[111]
48
dup
----------
[111,111]
49
outa:::::::::
o----------
[111]
50
push
----------
[111,3]
52
----------
[114]
53
dup
----------
[114,114]
54
outa:::::::::
r----------
[114]
55
push
----------
[114,6]
57
sub
----------
[108]
58
dup
----------
[108,108]
59
outa:::::::::
l----------
[108]
60
push
----------
[108,8]
62
sub
----------
[100]
63
outa:::::::::
d----------
[]
64
push
----------
[33]
66
outa:::::::::
!----------
[]

Any reason you used that particular song? – user – 2021-01-13T00:31:09.213

3@user simply because it's one of my favourite memes. All the languages requires is that the characters be present: I could have made this a boring submission with random letters. Instead, I made it somewhat entertaining. – Lyxal – 2021-01-13T00:33:01.823

1Great job! I'm glad to see people using Length. – Nailuj29 – 2021-01-20T14:35:58.053

4

# Brainfuck, 128 bytes

Generated using this generator, which is sub-optimal.

-[------->+<]>-.-[->+++++<]>++.+++++++..+++.[->+++++<]>+.------------.---[->+++<]>.-[--->+<]>---.+++.------.--------.-[--->+<]>.

4

# unc, 38 bytes

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

4

# LOLCODE, 22 bytes

VISIBLE"Hello, World!"

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

1Agh! Posted a minute before me :P – Kade – 2015-08-28T13:57:07.257

@Shebang Gotta go fast! – Fatalize – 2015-08-28T13:57:53.627

damn I'm a few days to late :( – Alex Carlsen – 2015-09-01T11:54:20.647

2And I pronounce this code, Ungolfable! – Erik the Outgolfer – 2016-06-04T13:01:25.560

4

# T-SQL, 20 bytes

print'Hello, World!'

Try it online

4

# Nim, 20 19 bytes

echo"Hello, World!"

Saved one byte thanks to sp3000!

You can drop the space in between for the first one, I think :) – Sp3000 – 2015-08-28T15:09:14.370

Indeed, saved me one byte! – kvill – 2015-08-28T15:18:54.417

4

# Emily, 22 bytes

println"Hello, World!"

This is a nice little language I stumbled upon recently.

4

# TI-BASIC, 22 bytes

"Hello, World!

Note that the lowercase letters are 2 bytes each.

4I don't think the initial : is really part of the program, so I think this has a score of 22. – Ypnypn – 2015-08-28T16:06:45.993

@Ypnypn I'll take your word on it :) – TheNumberOne – 2015-08-28T18:45:47.507

4

# VBScript, 28 Bytes

WScript.Echo "Hello, World!"

This (should be) the shortest that prints to STDOUT (i.e., the command prompt window), when executed via command prompt wscript .\hello-world.vbs or cscript //nologo .\hello-world.vbs (the //nologo is necessary to prevent copyright info from being displayed). If you just double-click it, you'll get a pop-up message box instead, similar to the shorter example, below, at 22 bytes:

MsgBox "Hello, World!"

When executed, this second option will output a pop-up message box displaying the text inside the quotes. Since it's not technically STDOUT, and we do have a legitimate way to display STDOUT, we'll count the longer version instead.

4

# Ook!, 949 Bytes

Just translated one of the Brainfuck answers here.

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

2I always smile when I see this language. – AdmBorkBork – 2015-08-28T16:36:12.037

2This might be a case of "If your language of choice is a trivial variant of another (potentially more popular) language...". The shortest Ook! program will always be the translation of the shortest BF program (because each BF character is converted to the same length in Ook). So if Ook has a separate answer it needs to be updated every time someone finds a new shortest Brainfuck solution. (Ultimately, it's your call though if Ook should remain separate.) – Martin Ender – 2015-08-28T17:06:03.263

3I love reading the "Code" in a manner as if two people were talking to each other :) – MrPaulch – 2015-08-29T11:12:11.430

@MrPaulch I agree. The fact that first O is capitalized makes it sound like a fast Oh, okay with vocalized differences for punctuation in my mind. – mbomb007 – 2015-09-01T15:04:43.720

4

# Vim, 17 bytes

iHello, World!{ESC}ZZ

Where {ESC} is a raw escape byte \x1b.

This will switch to insert mode (i), write Hello, World!, leave it (ESC), and save+quit (ZZ). An environment like vimgolf or anarchy golf has to do the output part for you, as Vim is, of course, just a text editor.

@LegionMammal978 the other seems to be Vimscript mislabelled as Vim. – primo – 2016-02-26T18:33:47.590

3I think generally the standard is that vim solutions don't have to save and quit, they can just display the text onscreen at the end. (That's what mine have all done). This would allow you to take 3 bytes off. – James – 2016-06-29T17:33:25.903

Way longer and wrong output, but more interesting: :h_4<CR>/"H<CR>ly2wZZp – BlackCap – 2017-10-12T19:22:36.120

4

# Octave, 19 bytes

disp"Hello, World!"

4

# Go, 64 61 bytes

3 bytes thanks to George Gibson

package main
import."fmt"
func main(){Print("Hello, World!")}

Go requires an import to print to standard output, unfortunately. No trailing newline.

package main;fund main(){print("Hello, world!")} – Eric Lagergren – 2015-09-06T16:53:00.370

1

@eric_lagergren That prints to STDERR, not STDOUT. See here

– isaacg – 2015-09-06T22:04:32.890

Oh gotcha. Never looked it up because I never use it. Thanks. – Eric Lagergren – 2015-09-06T22:06:06.120

Save 3 bytes by importing fmt into the global namespace with import."fmt" then just call Print("Hello, World!"). – George Gibson – 2016-06-05T09:45:30.937

@GeorgeGibson Thanks, that's a nice trick. – isaacg – 2016-06-05T17:24:14.593

4

# Q, 16 bytes

1"Hello, World!"

Just Y to go and we have the alphabet :)

Bit of a late update, but thanks to Mauris, we now have at least one language for every letter of the alphabet :D

Thanks @AaronDavies

1Not quite the requested output. I think you want 1"Hello, World!"; (doesn't include the trailing newline; to add one, change the 1 to a -1). Note, also valid for k. – Aaron Davies – 2015-08-29T23:19:55.637

4

# PARI/GP, 22 bytes

print("Hello, World!")

4

# 3var, 65 bytes

iiisa-<*>P/>is+iP>PPm-iiiPi<O/<m/>+<O+d<+<O+><kkkOP->siskkkOP</>P

Here's a 3var program found by brute force. Note that this might not be optimal since I assume that we'll only ever need numbers in the range 0-150, for efficiency reasons. I'll probably address this in a later edit.

3var is a Deadfish variant which has, well, three variables A, B and R. The relevant commands are:

Command              A           B           other
-----------------------------------------------------------
Increment            i           a
Decrement            d           k
Square               s           m
Output as char       P           O
Copy from R          >           <
Set R = A+B                                  +
Set R = A-B                                  -
Set R = A*B                                  *
Set R = A div B                              /

And here's a trace:

Line           A     B     R     Output
----------------------------------------------------------------
iiisa-         9     1     8
<*             9     8     72
>P             72    8     72    H
/>             9     8     72    H
is+            100   8     108   H
iP             101   8     108   He
>PP            108   8     108   Hell
m-             108   64    44    Hell
iiiP           111   64    44    Hello
i<O            112   44    44    Hello,
/<m            112   4     2     Hello,
/>             28    4     28    Hello,
+<O            28    32    32    Hello,
+d<            27    60    60    Hello,
+<O            27    87    87    Hello, W
+><            114   114   114   Hello, W
kkkOP          114   111   114   Hello, Wor
->             3     111   3     Hello, Wor
siskkkOP       100   108   3     Hello, World
</             100   3     33    Hello, World
>P             33    3     33    Hello, World!

@LegionMammal978 Do you mean esolang wiki? The site seems fine to me... – Sp3000 – 2015-09-28T02:39:50.243

4

# 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'. – mbomb007 – 2015-09-01T14:48:23.397

@mbomb007 Qo', jIHvaD pIch, bing pIch – Beta Decay – 2015-09-01T14:51:21.240

What language is this? – LegionMammal978 – 2015-09-28T01:00:21.467

1@LegionMammal978 Klingon :) – Beta Decay – 2015-09-28T05:52:36.410

4

# Piet, 132 codels

On a 4x33 grid. On the last few commands I had to stretch to reach the end, meaning it could be golfed a little more (it probably fits on a 4x31 grid). Here it is, with codel size 10:

I made it in a rectangular space to minimize the number of time I needed to flip the pointer. The stack is based on numbers 36 and 108 that are constantly being duplicated or rolled to produce the new letters.

4

# Beam, 312 161 bytes

'''''''''>++++++++)@'''''''>++++)+@+++++++@@+++@L'''''>+++++++++)-@'''>----)@'''''>+++++++++++)@'''''>+++++)-@+++@------@--------@'''''''>---------)----@H

Try it online!

Beam is a 2D language similar to Befunge. Thanks to @MickyT for helping me golf it down.

Beam is based on several memory components:

• The beam, the main integer value
• The store, a secondary integer value
• The memory, an array of integer storage

I've only used the beam and the store here.

Used commands:

• + and - increment and decrement the beam by 1, respectively.
• @ outputs the beam as an ASCII character.
• ' and  increment and decrement the store by 1, respectively.
• ) sends the beam to the left if the store's value is not 0.
• > sends the beam to the right. Combined with ), this is used here to make a loop.
• L sets the beam to the store's value (0 in this case).
• H halts the program. Not sure if this is necessary.

Looking at the constants at the bottom of the esolangs page, you could make use of the beam bouncing. For example 72 could be built like '''''>\++++++++) – MickyT – 2015-09-05T02:03:57.353

Using constants like that (assuming I got it right) reduces it to 136. Probably better ways to do this still. '''''>++++++++)@'''''''>++++)+@''>++)+@@+++@L''''''>----)@''>----)@''''''>-----)@'''>++++++++)@+++@------@''>---)@L''''''>+++)@ – MickyT – 2015-09-05T02:32:16.613

@MickyT There's no better way to get someone interested in an obscure esolang than to post an ungolfed solution in that language... ;) BTW, are all the double graves supposed to be single? – ETHproductions – 2015-09-05T15:10:43.570

@MickyT Actually, each of the graves will be run through twice in each loop (right at the beginning and right at the end), so there needs to be twice as many apostrophes beforehand. I'll update the post once I fix this. – ETHproductions – 2015-09-05T15:22:19.267

Oops, I miscounted the decrementers in the loop. Counted them once instead of twice on the turn around and I escaped them wrong when I posted to the comment. – MickyT – 2015-09-05T19:25:07.727

The H is, in fact, not neccessary. – Pavel – 2016-12-15T04:42:57.677

@Pavel You are correct. I removed the error for the beam leaving the source code when I ported it to TIO. Thanks :-) – ETHproductions – 2016-12-15T12:44:43.633

Small optimised version. 159 bytes, changes the ending to use 2 less -. Try it online!

– Teal pelican – 2016-12-16T11:26:37.733

Scrap that! I used the memory store in a little better way (storing o) and re-used it a bunch to come up with this 141 bytes; Try it online!

– Teal pelican – 2016-12-16T11:37:29.240

– ETHproductions – 2016-12-25T21:11:53.350

4

# Bubblegum, 11 bytes

0000000: 15 27 4d 50 62 a9 9a 29 6b 6d e2  .'MPb..)km.

Although technically Turing complete, Bubblegum was made for constant-output challenges.

Try it online!

4

# Gol><>, 16 bytes

"!dlroW ,olleH"H

I've really enjoyed golfing in ><>, but unfortunately I've found that ><> lacks several features, e.g. STDIN integer input, which prevent it from being competitive in challenges it otherwise would be. Gol><> is designed to (hopefully) be an easier-to-use variation of ><>. I worked on it earlier in the year, around when the language showcase was happening, but took a break and only picked it up again recently. It's starting to stabilise, so I thought it'd be a good time to post a first answer.

Similarly to ><>, " is a string parsing operator which pushes chars one at a time until it reaches a closing ". H then halts the program, outputting the stack until it is empty.

Even without H, Gol><> can still output the stack in a relatively short way. l pushes the length of the stack, o outputs a char from the stack and R pops a number n, repeating the next instruction n times. Thus, an equivalent program would be

"!dlroW ,olleH"lRo;

where ; terminates the program with no output.

Another solution would be S"Hello, World!". – LegionMammal978 – 2015-11-09T12:39:09.450

@LegionMammal978 Indeed :) (although you'll need a ; at the end or it'll print forever) – Sp3000 – 2015-11-09T12:43:25.380

4

# Vitsy, 18 16 bytes

"!dlroW ,olleH"Z

"!dlroW ,olleH"     Push Hello, World! to the stack.
Z    Push the entire stack to STDOUT - equivalent to l\O

Output:

Hello, World!

Z is new syntax - it was not made for this question.

4

# Japt, 1514 11 bytes

(using the ISO/IEC 8859 character encoding)

Japt is a shortened version of JavaScript. Interpreter

HÁM, Wld!

There's an unprintable char in there, so here's a hexdump:

60 48 C1 4D 2C 20 57 8E 6C 64 21
H  Á  M  ,     W  .  l  d  !

Recently, @Vɪʜᴀɴ has helped me add in the shoco library for compressing strings. Using backticks around a string tells the interpreter to automatically decompress the string, and when a backtick is needed at the end of a program, you can leave it off. Thus, Japt now beats or ties all languages that don't have some sort of built-in to obtain "Hello, World!". (Including Pyth :D)

4

# TeaScript, 12 bytes

(using ISO/IEC 8859 character encoding)

DHÁM, Wld!

Compresses Hello, World!, decompresses with D (æ) function

This is 12 bytes, I think; there should be an unprintable in Wl. – ETHproductions – 2016-01-08T02:58:04.570

@ETHproductions you're right, whoops. I guess SE kills unprintables – Downgoat – 2016-01-08T02:58:55.863

2Perhaps a hexdump would be useful (via xxd or similar). – primo – 2016-01-08T04:25:03.240

4

## Purple, 62 bytes

AA1AA1AA1bA1b1Bo1bb1bbibb1Bi1b
! d l r o W   , o l l e H

### Purple in a Nutshell:

Purple is a self-modifying language in the same sense that self-modifying brainfuck is: The code is executed from the same array that contains data, which is infinite and otherwise initialized with zeroes. It has one instruction with three arguments: subtract the third argument from the second and store it in the first. It has two registers, a and b, which can be dereferenced as A and B to get the contents of that memory address. It also has i, the instruction pointer, o which represents the outside world (i.e., stdout in the first argument, stdin in either of the other two), and the literal 1, which cannot be the first argument.

It is as hard to read and write as it looks.

### This Program:

It may seem strange that I'm entering a program that is almost more not-code than code in a contest for "shortest program", but it would be REALLY DIFFICULT to do it in less. The reason is that, when doing loops in Purple, it requires the least effort to jump to memory location 3 (because you just set i to 0), but this means you have exactly one instruction to initialize the loop. This means we need to set A to the location of the first character to be printed in a single instruction. Otherwise, we'd have to do a lot of extra work to jump somewhere else at the end of each loop. But since a starts out at zero, the only positive value we can set it to in a single instruction is 64. (i.e. the contents of the zeroth cell--the "A" itself, which is ASCII 65, minus one.)

Obviously, we're going to want to iterate backwards over the string since

• Iterating forwards means we have to put the string AFTER position 64, thereby making the program longer.
• It takes one fewer instruction to decrement the pointer than to increment it.

And we can shave bytes off the end of the program by decrementing the pointer before we print. In fact, we have enough space between the cell 64 and the end of the program to decrement twice between each address to be printed. Thus, the first character we need to print can be at character 62, hence, exactly 62 bytes long.

### Here's The Nitty:

AA1               Set the first cell to 64
AA1AA1            This is the entry point for the loop. M[0]=M[0]-2
bA1               Point b the cell to the left of what cell 0 points to.
b1B               Set b to one more than the opposite of the character there.
o1b               Output the character M[0] pointed to (one more than the opp. of b)
b1b               Set b to the just output character.
bib               Subtract the just output character from the IP (24)
Until we hit the newline (ascii 10), this yields a negative.
b1B               Set b to 1 minus what b was pointing to.
Negative addresses are initialized to zero, so until we hit the newline
this will set b to 1. When we hit the newline, b will be pointing to
the 11th character ("1"), and this will set it to -48.
i1b               Set the instruction pointer to 1-b.
Until the newline, this sets i=0, jumping back the beginning of the loop.
After the newline, this sets i=49, where it finds the
non-instruction "W  ", and Purple halts without error in such a case.

The rest of the program is the string itself and arbitrary padding to position the characters in the right place.

EDIT: Figured out how to save 30 bytes on this program, and updated all explanations to match the new version.

4

# BTClang, 53 bytes

My newest invention! BTClang is short for Bitcoin language. Although it has nothing to do with bitcoins, it shares some similiarities with this language. Code:

4|$&2h 2|A% 3|Im! 3|%([F 2|!4P 2|"Cv 3|zJO 1|!M 2|!&r Explanation: First of all, each line of the code consists of a number, a pipe and a key. The process goes as following for the example 2|5C. We take the key (5C), and generate the SHA256-hash of it. We get this: ad5d3cc03d8b60e308b22e27fe4bbccae6a83d5496bc5e2a36aeb76eae51aeb0 The number before the pipe says how many hexadecimal number we want to extract from the end of the hash. This number is 2, so we take two 2-digit hexadecimal numbers from the end of the hash. We are left with ae and b0. Converting these to integers will result into 174 and 176. These will be processed with the formula n % 94 + 32, so when this is converted to a character, the character will always be a printable ASCII character with 31 < ord < 128. The hashtags are replaced with newlines. 174 % 94 + 32 = 112 (p) 176 % 94 + 32 = 114 (r) And so on... The final translation of the code is print("Hello, World!"), which is then evaluated as normal Python. Although this is a solution, I am pretty sure this can be golfed further. It just takes a lot of computational power... (By the way, you can try to find sets of characters yourself with the BTClang_miner) How do you choose which hexadecimal numbers? – Conor O'Brien – 2016-04-08T00:32:54.433 1@CᴏɴᴏʀO'Bʀɪᴇɴ You mean from the hash? The numbers chosen are all taken from the end of the hash. So from ad5d3cc03d8b60e308b22e27fe4bbccae6a83d5496bc5e2a36aeb76eae51aeb0, the last two hexadecimal numbers are ae and b0. – Adnan – 2016-04-08T14:15:18.847 Oh, I'm an idiot. :| – Conor O'Brien – 2016-04-08T14:41:34.160 4 # Scratch, 15 bytes (scoring used) Makes the sprite say "Hello, World!" Can't get much simpler than that. You already welcomed me in Output the Current Time – weatherman115 – 2016-05-20T15:25:58.783 Sorry, the review link said you were new. – NoOneIsHere – 2016-05-20T15:35:29.757 Is this different from https://codegolf.stackexchange.com/a/76182/6691 ? – b_jonas – 2017-04-17T13:31:17.403 Well, this is awkward. – weatherman115 – 2017-04-17T18:06:38.710 4 # 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

4

'Hello, World!

## Explanation

'...
'... - Push the string. The ending ' is not needed at the end of program
- Implicit output

4

# Emojicode, 37 bytes

Hello, World!

4

# Golfuck, 39 bytes

jrseeqzjzzzsvDsj*aaa*r"s*hB(FsxahB(z*sh

Credit to primo, this is his answer, but in Golfuck.

4

Addict is my new Turing-tarpit esolang, based on PRINDEAL.

a A
i 1
i 1
d
a B
A 1
A 1
d
a C
B 1
B 1
d
a D
C 1
C 1
d
a E
D 1
D 1
d
E H
E H
C H
c H
E e
E e
E e
B e
i e
c e
E l
E l
E l
C l
B l
c l
c l
E o
E o
E o
D o
d o
c o
E c
C c
B c
c c
E s
c s
D H
d H
c H
c o
A o
i o
c o
c l
d e
c e
i s
c s

Test it online here!

• All memory is stored in variables. Variables can hold only non-negative integers; all variables start out at 0.
• Addict has 4 built-in commands: decrement, increment, print a charcode, and take a charcode from input.
• You can define your own commands with alias. This has very strict syntax:

a commandname
command1
command2
command3

This creates a new command called commandname. Whenever commandname is called, the following process happens:

• command1 is called.
• If command1 succeeded, command2 is run.
• If command1 failed, command3 is run.

## Act I

The first part of the program defines five commands: A, B, C, D, and E. Each one has this format:

a A
i 1
i 1
d

This defines a command A which adds two to the input through the following process:

• increment the 1st input.
• If this succeeded, increment again. (i always succeeds unless it has no argument.)
• Otherwise, decrement nothing. (This never gets run for the above reason.)

The next command defined is B, which adds 4 to the input:

a B
A 1
A 1
d

• Run A on the 1st input. (Always succeeds.)
• If this succeeded, run A again. (Always gets run.)
• Otherwise, decrement nothing. (Never gets run.)

## Act II

The rest of the program is devoted to outputting Hello, World! in as few bytes as possible. The charcodes we need to output are 72 101 108 108 111 44 32 87 111 114 108 100 33, in that order. The shortest method I have found to output them all is to use six variables:

• H to output 72 and 87
• e to output 101 and 100
• l to output 108
• o to output 111 and 114
• c to output 44
• s to output 32 and 33

Here's a table of commands, and the values of the variables after each command:

Command  Output   H   e   l   o   c   s
E H              32   0   0   0   0   0
E H              64   0   0   0   0   0
C H              72   0   0   0   0   0
c H      H       72   0   0   0   0   0
E e              72  32   0   0   0   0
E e              72  64   0   0   0   0
E e              72  96   0   0   0   0
B e              72 100   0   0   0   0
i e              72 101   0   0   0   0
c e      e       72 101   0   0   0   0
E l              72 101  32   0   0   0
E l              72 101  64   0   0   0
E l              72 101  96   0   0   0
C l              72 101 104   0   0   0
B l              72 101 108   0   0   0
c l      l       72 101 108   0   0   0
c l      l       72 101 108   0   0   0
E o              72 101 108  32   0   0
E o              72 101 108  64   0   0
E o              72 101 108  96   0   0
D o              72 101 108 112   0   0
d o              72 101 108 111   0   0
c o      o       72 101 108 111   0   0
E c              72 101 108 111  32   0
C c              72 101 108 111  40   0
B c              72 101 108 111  44   0
c c      ,       72 101 108 111  44   0
E s              72 101 108 111  44  32
c s      (space) 72 101 108 111  44  32
D H              88 101 108 111  44  32
d H              87 101 108 111  44  32
c H      W       87 101 108 111  44  32
c o      o       87 101 108 111  44  32
A o              87 101 108 113  44  32
i o              87 101 108 114  44  32
c o      r       87 101 108 114  44  32
c l      l       87 101 108 114  44  32
d e              87 100 108 114  44  32
c e      d       87 100 108 114  44  32
i s              87 100 108 114  44  33
c s      !       87 100 108 114  44  33

If you can find any way to golf this program, please let me know!

Wow, this is a great language. Nice work! – Conor O'Brien – 2016-09-27T18:58:00.787

Seeing that 108, 111 and 114 are part of the output, maybe an alias to add 3 might help? – Martin Ender – 2016-09-27T18:58:27.720

@MartinEnder Thanks for the suggestion. An alias to add N will cost at least 17 bytes, so it'd need to save at least 5 lines (4 bytes each) to be worth it. (I originally had an alias F to add 64, but I only used it 4 times, so getting rid of it saved 1 byte.) – ETHproductions – 2016-09-27T19:01:36.347

@ConorO'Brien Thanks, I'm glad you like it! After spending a few months designing it, writing sample programs, and wishing I had time to code it, it took me about 4 hours to code: by far my shortest start-to-finish esolang implementation. ;) – ETHproductions – 2016-09-27T19:08:27.253

@Martin Using aliases for adding 2 3 6 12 24 48 seems to be about 7 bytes longer, but perhaps there's a different optimal set of aliases. I might write a brute-forcer when I have time. – ETHproductions – 2016-09-29T01:59:34.983

@ETHproductions Please publish it too, I wrote a longer program for the same thing before I discovered you had answered. – Erik the Outgolfer – 2016-10-21T14:07:51.237

3

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

3

# 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. 3 # 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 3 # Threead, 16 bytes "Hello, World!"o Try it online! Also works in Check. – Esolanging Fruit – 2017-05-30T02:06:12.447 3 # 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. 3 # 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. 3 # ;# 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 [tag:kolmogorov-complexity]. – Erik the Outgolfer – 2017-05-07T17:49:05.243 @EriktheOutgolfer yeah yeah, you know what I mean. – caird coinheringaahing – 2017-05-15T19:14:04.383 3 # 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 :) 3 # CRPL and its sister language PRPL, 21 bytes Bit of an obscure language, but the official tutorial doesn't contain a Hello World program so this at least is worth something. "Hello, World!" Trace "Hello, World!" pushes the string Hello, World! to the stack, and Trace pops an item from the stack and add it to the trace log, the closest thing the language has to SDTOUT or a console. Alas, for this language is too obscure for Dennis's gadget; however, I have written the following interpreter in JS with all the complexity needed for this demo. I may one day make it support more. var code = '"Hello, world!" Trace'; var stack = []; var vars = Object.create(null); var literals = []; code = code.replace(/"(.*?)"/g, (m,$1) => 'lit' + [literals.length, literals.push($1)][0]).split(/\s/); for (var token of code) { if (token.match(/^lit(\d+)$/)) {
stack.push(literals[token.slice(3)]);
} else if (token.match(/^-?\d+.?\d*/)) {
stack.push(+token);
} else if (token.startsWith('<-')) {
stack.push(vars[token.slice(2)]);
} else if (token.startsWith('->')) {
vars['v' + token.slice(2)] = stack.pop();
} else {
switch(token) {
case 'Trace5':
console.log(stack.pop());
case 'Trace4':
console.log(stack.pop());
case 'Trace3':
console.log(stack.pop());
case 'Trace2':
console.log(stack.pop());
case 'Trace':
console.log(stack.pop());
break;
default:
throw new Error(token + 'is not implemented.');
}
}
}

No language is too obscure, you just have to ask for it on https://talk.tryitonline.net lol

– ASCII-only – 2018-04-11T06:34:18.193

Yeah probably. You could've just edited it yourself. – Nissa – 2019-12-06T22:54:43.013

3

# Broccoli, 23 bytes:

(print "Hello, World!")

Broccoli is a random language I ran across whilst recording the PPCG podcast. I promised that I would post an answer in it, so here it is. The better way of writing this (in 28 bytes) would be:

(print "Hello, World!" endl)

But since the newline is optional, this works.

Just finished the PPCG podcast this morning! Is there documentation available for Broccoli? – Esolanging Fruit – 2018-02-11T06:47:02.670

@EsolangingFruit I'm glad to hear it! :) There is a little bit of documentation in the folder, but it's pretty minimal. Mostly examples. But there is also a project to re-write it. You can ask for ask for help from the people there or in chat or on github.

– James – 2018-02-11T07:12:11.817

3

## 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! 1Welcome to PPCG! / Using inline code formatting can be quite hard to read, I edited the answer. – user202729 – 2018-02-02T10:29:38.210 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 – 2018-02-06T22:21:59.020 According to the original site, (and by the number of folders) it is with the comma. I fixed my concise example. – Eran W – 2018-02-07T00:44:15.863 1Easier way to count: find * -type f | wc -l (counts lines of output) – Peter Cordes – 2018-04-13T02:57:04.627 Right, It is shorter by one character... But I could use -lR – Eran W – 2018-04-14T08:21:48.747 If your filesystem is NTFS you need 4kb per folder (for metadata and such) so this answer is probably 4096 bytes x 195 folders, i.e. approx 798720 bytes. Not a golfing language! :P – roblogic – 2019-05-05T22:58:12.653 3 ## 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. 3 # Forked, 42 bytes 89*@AA*i@7+@@3+@4B*@C'!sF+!@3+@6'@8'!3B*!& Try it online! 3 # AlphaBeta, 68 bytes kjjjggDLeaCLcbbbCLLaaaCLjjjggDLjhhDLsFihhDLCLaaaCLdaaaaCLdaaCLsFiiDL Try it online! 3 # 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! 3 # Aubergine, 29 bytes -a1=oA-a1:bA=iB\0!dlroW ,olleH Where \0 is a null byte Try it online! ### Explanation -a1 Decrement a (now points to H) =oA Output *a (loop starts here) -a1 Decrement a :bA If *a is not 0 (we're not at null byte), jump to b (which is 0). IP then moves by 3, so IP starts at 3 next tick =iB Else move IP to *b, which is the character code of -, moving us out of bounds and ending execution without error. \0!dlroW ,olleH 3 # Rockstar, 21 bytes Shout "Hello, World!" Yeah, kinda boring... oh well. 8You can save 2 bytes by using Say instead of Shout. – RamenChef – 2018-09-27T13:58:52.373 3 # Pikachu, 1562 bytes So simple even Pikachu can do it! pi pi pika pi pi pika pi pi pika pi pikachu pi pika pi pika pikachu pi pika pika pikachu pi pika pi pi pika pi pi pika pi pikachu pi pikachu pi pikachu pikachu pikachu pi pikachu pika pi pika pi pi pikachu pi pikachu pi pi pikachu pi pika pi pikachu pikachu pikachu pi pikachu pika pi pika pi pi pikachu pi pikachu pi pi pika pi pi pika pi pika pi pikachu pi pika pi pikachu pikachu pikachu pi pikachu pika pi pika pi pi pikachu pi pikachu pi pi pika pi pi pika pi pika pi pikachu pi pika pi pikachu pikachu pikachu pi pikachu pika pi pika pi pi pikachu pi pikachu pi pi pika pi pi pika pi pi pika pi pika pi pikachu pi pika pi pikachu pikachu pikachu pi pikachu pika pi pi pi pika pi pi pikachu pi pikachu pi pikachu pi pi pika pi pi pikachu pi pika pi pikachu pikachu pikachu pi pikachu pika pi pi pi pika pi pikachu pi pikachu pi pikachu pikachu pi pi pikachu pi pika pi pikachu pikachu pikachu pi pikachu pika pi pi pika pi pi pika pi pi pika pi pikachu pi pikachu pi pikachu pika pi pi pika pi pi pika pi pikachu pi pika pi pikachu pikachu pikachu pi pikachu pika pi pika pi pi pikachu pi pikachu pi pika pi pika pi pi pika pi pi pika pi pi pika pi pikachu pi pika pi pikachu pikachu pikachu pi pikachu pika pi pi pika pi pi pika pi pi pika pi pi pika pi pi pika pi pikachu pi pika pi pikachu pikachu pikachu pi pikachu pika pi pi pika pi pi pika pi pi pika pi pikachu pi pika pi pikachu pikachu pikachu pi pikachu pikachu pikachu pika pikachu pika pi pi pi pika pi pikachu pi pika pi pikachu pi pikachu pika pi pi pika pi pikachu pikachu pikachu pi pikachu Try it at Trove42! (Copy and paste above text) ### Commented # H pi pi pika pi pi pika pi pi pika pi pikachu # push 9 to pi stack pi pika # copy top of pi stack, 9, to pika stack pi pika pikachu # push 1 to pika stack pi pika pika pikachu # add top two elements of pika stack # push result, 10, to pika stack pi pika pi pi pika pi pi pika pi pikachu # push 9 to pi stack pi pikachu pi pikachu # multiply top two elements of pi stack # push result, 72, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 72, # to ASCII, 'H', and print # e pika pi # copy top of pika stack, 10, to pi stack pika pi # copy top of pika stack, 10, to pi stack pi pikachu pi pikachu # multiply top two elements of pi stack # push result, 100, to pi stack pi pi pikachu # push 1 to pi stack pi pika pi pikachu # add top two elements of pi stack # push result, 101, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 101, # to ASCII, 'e', and print # l pika pi # copy top of pika stack, 10, to pi stack pika pi # copy top of pika stack, 10, to pi stack pi pikachu pi pikachu # multiply top two elements of pi stack # push result, 100, to pi stack pi pi pika pi pi pika pi pika pi pikachu # push 8 to pi stack pi pika pi pikachu # add top two elements of pi stack # push result, 108, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 108, # to ASCII, 'l', and print # l pika pi # copy top of pika stack, 10, to pi stack pika pi # copy top of pika stack, 10, to pi stack pi pikachu pi pikachu # multiply top two elements of pi stack # push result, 100, to pi stack pi pi pika pi pi pika pi pika pi pikachu # push 8 to pi stack pi pika pi pikachu # add top two elements of pi stack # push result, 108, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 108, # to ASCII, 'l', and print # o pika pi # copy top of pika stack, 10, to pi stack pika pi # copy top of pika stack, 10, to pi stack pi pikachu pi pikachu # multiply top two elements of pi stack # push result, 100, to pi stack pi pi pika pi pi pika pi pi pika pi pika pi pikachu # push 11 to pi stack pi pika pi pikachu # add top two elements of pi stack # push result, 101, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 111, # to ASCII, 'o', and print # "," (comma) pika pi # copy top of pika stack, 10, to pi stack pi pi pika pi pi pikachu # push 4 to pi stack pi pikachu pi pikachu # multiply top two elements of pi stack # push result, 40, to pi stack pi pi pika pi pi pikachu # push 4 to pi stack pi pika pi pikachu # add top two elements of pi stack # push result, 44, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 44, # to ASCII, ',', and print # " " (space) pika pi # copy top of pika stack, 10, to pi stack pi pi pika pi pikachu # push 3 to pi stack pi pikachu pi pikachu # multiply top two elements of pi stack # push result, 40, to pi stack pikachu pi pi pikachu # push 2 to pi stack pi pika pi pikachu # add top two elements of pi stack # push result, 32, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 32, # to ASCII, ' ', and print # W pika pi # copy top of pika stack, 10, to pi stack pi pika pi pi pika pi pi pika pi pikachu # push 8 to pi stack pi pikachu pi pikachu # multiply top two elements of pi stack # push result, 80, to pi stack pika pi pi pika pi pi pika pi pikachu # push 7 to pi stack pi pika pi pikachu # add top two elements of pi stack # push result, 87, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 87, # to ASCII, 'W', and print # o pika pi # copy top of pika stack, 10, to pi stack pika pi # copy top of pika stack, 10, to pi stack pi pikachu pi pikachu # multiply top two elements of pi stack # push result, 100, to pi stack pika pi # copy top of pi stack, 100, to pika stack pi pika pi pi pika pi pi pika pi pi pika pi pikachu # push 11 to pi stack pi pika pi pikachu # add top two elements of pi stack # push result, 111, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 101, # to ASCII, 'o', and print # r pika pi # copy top of pika stack, 100, to pi stack pi pika pi pi pika pi pi pika pi pi pika pi pi pika pi pikachu # push 14 to pi stack pi pika pi pikachu # add top two elements of pi stack # push result, 114, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 114, # to ASCII, 'r', and print # l pika pi # copy top of pika stack, 100, to pi stack pi pika pi pi pika pi pi pika pi pikachu # push 8 to pi stack pi pika pi pikachu # add top two elements of pi stack # push result, 101, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 101, # to ASCII, 'e', and print # d pikachu pikachu pika pikachu # convert top of pika stack, 100, # to ASCII, 'd', and print # "!" (exclaimation point) pika pi # copy top of pika stack, 10, to pi stack pi pi pika pi pikachu # push 3 to pi stack pi pika # copy top of pi stack, 3, to pika stack pi pikachu pi pikachu # multiply top two elements of pi stack # push result, 30, to pi stack pika pi # copy top of pika stack, 3, to pi stack pi pika pi pikachu # add top two elements of pi stack # push result, 33, to pi stack pikachu pikachu pi pikachu # convert top of pi stack, 33, # to ASCII, '!', and print 3 # , 21 bytes ("Hello, World!") Try it online! This is a language written in Cuneiform, and uses Sumerian words as keywords. At its heart, this is just a translation of Python into Sumerian, but in the future there will be new features added, such as the Babylonian numeral system (which works in base 60). Because it relies heavily on unicode, this is not going to be a very good golfing language. You could always translate from unicode to a golfier encoding :P – ASCII-only – 2018-12-26T00:10:57.123 3 # ESOPUNK, 191 COPY 72 #STDO COPY 101 #STDO COPY 108 #STDO COPY 108 #STDO COPY 111 #STDO COPY 44 #STDO COPY 32 #STDO COPY 119 #STDO COPY 111 #STDO COPY 114 #STDO COPY 108 #STDO COPY 100 #STDO COPY 33 #STDO Can probably save some bytes by copying a constant to X, and ADDI/SUBI from it. 3 # Pixiedust, 153 bytes ++.*+..+... ++.*++..+.+ ++.*++.++.. ++.*++.++.. ++.*++.++++ ++.*+.++.. ++.*+..... ++.*+.+.+++ ++.*++.++++ ++.*+++..+. ++.*++.++.. ++.*++..+.. ++.*+....+ Try it online! ## Explanation Each line of the program is: • ++ indicating that this line prints the following to STDOUT; • .*, the portal register indicating a number literal; and • A sequence of + and . characters forming the binary representation of the character to be printed. 3 # Kitten, 18 bytes "Hello, World!"say 3 # Alchemist, 24 22 bytes _->Out_"Hello, World!" Try it online! 3 # Grocery List, 94 bytes H w nnn d v d v l c u v r v o c u v W nn c c m c m m w nnn c m d nnnn m b b c v e v H l p e t Could you please link to the interpreter you used to test this? – Dennis – 2019-01-02T12:34:46.647 From the challenge spec: Note that there must be an interpreter so the submission can be tested. The only interpreter I know of is this one, but your program just prints H in it. – Dennis – 2019-01-02T12:59:25.410 fixed, but space can't print – u-ndefined – 2019-01-02T13:29:44.260 The output looks fine now, but the program seems to exit by popping from an empty stack and the challenge says The program must not write anything to STDERR. – Dennis – 2019-01-02T13:40:29.200 3 # Tamsin, 27 20 bytes main='Hello, World!'. This is an interesting language. 3 # Bitwise Cyclic Tag But Way Worse, 324 bytes 1111111111111111111111111111111111111111111111111111111110110101101010101110101101101110111010101110111010101110111110101101110101010110101010101011011011110111011111011110101101011101110101011101011010101011010101011n0200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 Try it online! 3 # legit, 1 commit, 67 bytes (commit messages), 179 + 3 = 182 bytes (repository) Commit tree: * 63c5d78 "!dlroW ,olleH" put put put put put put put put put put put put put The program is quite boring -- commits are expensive, and the messages are compressed, so there's little incentive to use proper control flow. The program in its proper representation consists of 4 files: .git/HEAD (21 bytes, an empty file here is still accepted by the interpreter, but git does not recognize the repository): ref:refs/heads/master .git/refs/heads/master (40 bytes): 63c5d7873f5b0ede65885bfdfd5c935827d6752a .git/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 (15 bytes, xxd): 00000000: 78da 2b29 4a4d 5530 6000 000a 2c02 01 x.+)JMU0...,.. .git/objects/63/c5d7873f5b0ede65885bfdfd5c935827d6752a (103 bytes, xxd): 00000000: 78da 04c1 4501 c030 0c00 c0bd a722 0e4a x...E..0.....".J 00000010: 4137 6366 f0df bbf6 dcf7 f983 80a1 f89e A7cf............ 00000020: be07 6c34 52d7 32c6 b6e1 beb1 dab3 ef09 ..l4R.2......... 00000030: 9b41 3bb6 a83a 347d 8fe6 b1ac ff6f 3a1f .A;..:4}.....o:. 00000040: f090 6763 c705 31a4 2415 cae5 5252 4cc9 ..gc..1.$...RRL.
00000050: 29ca 0f57 d0c9 cfc9 49f5 5052 2828 2d21  )..W....I.PR((-!
00000060: 1503 00bd ca30 75                        .....0u

hmm seems like you should measure repository size using a tar instead? – ASCII-only – 2019-05-04T01:01:21.700

@ASCII-only Is there precedent for this? Also, tar on my machine always creates at least 10240-byte files minimum, which removes almost all possibilities for golfing. Moreover, the filenames literally can't store any extra information - they are hashes of the content (after decompressing with zlib). – NieDzejkob – 2019-05-04T07:59:12.847

hmm. well the structure needs to be counted somehow. maybe some kind of tar archive instead? – ASCII-only – 2019-05-04T10:04:38.657

@ASCII-only I've found the relevant meta post for multi-file programs and linked it in the header of my answer. Can you take a look? – NieDzejkob – 2019-05-04T10:07:26.587

Looks fine now, but still feel like that's a bit hacky (e.g. it's impossible to make it work with 1-byte filenames) :/ IMO the best way to do this would be to count the bytes of a shell script to create the appropriate structure – ASCII-only – 2019-05-04T10:10:07.907

@ASCII-only That opens up a can of worms. For example: is using bash string interpolation or looping to compress the repeated puts allowed? – NieDzejkob – 2019-05-04T10:13:14.367

– ASCII-only – 2019-05-04T10:13:26.357

3

# 32 bit SPARC machine language on SunOS, 48 45 bytes

0x00:  40 00 00 02    call 0x8            ! PC relative jump, return addr to %o7
0x04:  82 10 20 04    mov  4, %g1         ! delay slot; select write() syscall
0x08:  90 10 20 01    mov  1, %o0         ! stdout is fd=1
0x0c:  92 03 E0 20    add  %o7, 32, %o1   ! put addr of string in %o1
0x10:  94 10 20 0d    mov  13, %o2        ! length of string
0x14:  91 D0 20 08    ta   %icc, %g0 + 8  ! call write()
0x18:  82 10 20 01    mov  1, %g1         ! select exit() syscall
0x1c:  91 D0 20 08    ta   %icc, %g0 + 8  ! call exit()
0x20:  48 65 6c 6c    "Hello, World!"
6f 2c 20 57
6f 72 6c 64
21

Porting to 64 bit SPARC requires changing the argument of the trap instruction from 8 to 64.

To try this on a SunOS machine, compile and run the following C program.

const char main[]="\x40\x00\x00\x02\x82\x10\x20\x04\x90\x10\x20\x01\x92\x03\xe0\x20\x94\x10\x20\x0d\x91\xd0\x20\x08\x82\x10\x20\x01\x91\xd0\x20\x08Hello, World!";

3

# Turing Machine But Way Worse, 853 bytes

0 0 0 1 1 0 0
0 1 1 1 2 0 0
0 2 0 1 3 0 0
0 3 0 1 4 0 0
0 4 1 1 5 1 0
0 5 1 1 6 0 0
0 6 0 1 7 0 0
0 7 1 0 8 0 0
0 8 0 0 9 0 0
1 9 1 0 a 0 0
1 a 0 0 b 0 0
0 b 0 0 c 0 0
0 c 1 1 d 1 0
0 d 0 1 e 0 0
0 e 1 1 f 0 0
1 f 1 1 g 0 0
0 g 0 1 g 0 0
1 g 0 0 h 1 0
0 h 0 1 i 1 0
0 i 1 0 i 0 0
1 i 1 1 j 1 0
1 j 1 1 k 0 0
1 k 1 1 l 0 0
0 l 0 1 m 0 0
0 m 0 1 n 0 0
0 n 1 1 o 0 0
0 o 0 1 p 0 0
0 p 1 1 q 0 0
0 q 1 0 r 1 0
1 r 0 1 s 0 0
1 s 0 1 t 1 0
0 t 0 1 u 0 0
0 u 1 0 v 0 0
0 v 0 0 v 0 0
1 v 1 0 w 0 0
0 w 0 0 w 0 0
1 w 1 0 x 0 0
1 x 1 0 x 0 0
0 x 1 1 y 0 0
1 y 0 0 z 0 0
1 z 1 0 A 0 0
1 A 0 1 B 1 0
1 B 0 1 C 0 0
0 C 1 0 D 0 0
0 D 0 0 E 0 0
0 E 1 1 F 1 0
0 F 1 1 G 0 0
1 G 0 1 G 0 0
0 G 0 0 H 0 0
0 H 0 0 I 0 0
0 I 1 0 J 1 0
0 J 1 0 J 0 0
1 J 0 1 K 0 0
1 K 1 1 K 0 0
0 K 0 0 L 0 0
1 L 0 0 M 1 0
1 M 1 0 N 0 0
1 N 0 1 O 1 0
1 O 0 1 P 0 0
0 P 0 1 P 0 0
1 P 1 1 P 1 1

Try it online!

3

## Nandy, 159B

Simply sets the stack to bits 0 and 1 and then puts them in the output stack.

o::#o>oo>o>oooo>oo>oo>o>o>o>o>oo>o>oo>ooo>oo>o>oo>ooo>oo>o>oooo>oo>o>o>oo>oooo>o>oooooo>o>o>o>o>ooo>o>oo>o>oooo>o>ooo>oo>o>oo>oo>o>oo>ooo>oo>oo>o>oooo>o>oooo>o

Wow, I'm surprised anyone noticed this language. This can probably be golfed quite a lot if you use a loop to output at the end – EdgyNerd – 2019-08-31T12:51:16.617

But how? Can you present you program? (I actually found your language by looking at your TIO request.) – None – 2019-08-31T13:15:17.180

I don't think using a loop at the end would be any shorter since it would be the same amount of bytes to output as it is to dupe a bit – Jo King – 2019-09-08T08:11:16.180

3

# 1+, 87 83 bytes

11+""+"""+"/*^/"\+""+";\\+"*"1+;/+""";;(|1+1+1+)";/^""1()"+()+"1+";+^;;\";();/;;1+;

Try it online!

This should be very golfable, but it is hard to golf 1+ directly.

Nice! I'm doing nothing now. – null – 2019-10-09T09:56:02.137

3

# Wd, 12 10 bytes (SBCS)

.s*♪╧T≈╪√ù

## Explanation

This program is a compressed program. After decompression this becomes:

J=QwTI[5mRb

After string-decompression:

Hello, World!"

After quote auto-completion:

"Hello, World!"

After which it is implicitly output.

3

# Ral, 103 bytes

What better way to introduce a new language than by posting the 768th "Hello, World!"?

Hand-made code, can probably be improved a lot.

11+:+:+:0=1+:+:+::+:.+0*/-::1+.0*+:::..1+1+1+::.0*:+:+:11+1+:+:++..10*1+1+1+:+:+:+-..1+1+1+...0*:+:+1+.

Try it online!

Cool language! I like the mix of stack and random access. – Redwolf Programs – 2020-04-12T23:25:24.557

3

## Spice, 20 bytes

@OUT "Hello, World!"

## Explanation

Should be pretty straight forward what's happening, but we use some undefined behaviour to shave off 2 bytes (interpreter version 1.1.0.0, which is current at time of submission). The program should read:

;@
OUT "Hello, World!";

as per the spec, but we drop the ; as we only have one instruction and don't need to define an instruction separator, and so also have no trailing ; at the end.

3

# Symbolic Raku, 34 bytes

$_='(%,,/ @)/),$!'~^'@@@@~@[@@'

Try it online!

My newest language, though it's not too original. This is inspired by FlipTack's Symbolic Python, which bans the use of alphanumeric characters, but otherwise executes as Python code. In this case, I've used the language Raku (previously known as Perl 6), which takes input through the $_ and similarly outputs it's contents at the end of execution. Symbolic Raku does not have an extra eval operator like Symbolic Python, but it is still Turing complete through the other operators and symbols that Raku provides. In this case, we use the string xor operator (~^), which takes two strings to produce the string Hello, World!, which is obviously banned from hardcoding because it contains letters. A shortcut for producing these strings is included in the reference implementation through the -g=string flag. Currently, this is not yet on TIO, so the link goes to the Raku language instead. 3 # Roj, 18 bytes I love this simple BASIC dialect ... out"Hello, World!" # Explanation out$ Output $"Hello, World!"$ the string "Hello, World" $3 # MAWP, 86 62 bytes 89W!;74WM1M!;7M!!;;3M;66W8M;84W;99W6M!;64WM!;3M!;6A!;8A;66W3A; Try it! 64 bytes – Lyxal – 2020-08-14T21:32:53.477 3 # Arn, 6 bytes 'Mh└a└ # Explanation Unpacked: 'yt, bs! A compressed string where every word is capitalized. Output is implicit 3 # CSS, 62 bytes: *{display:none}html{display:flex}:after{content:'Hello World!' This is the first pure CSS on here, I think. 3 # Fugue, 276 bytes 00000000: 4d54 6864 0000 0006 0001 0002 0001 4d54 MThd..........MT 00000010: 726b 0000 001b 0090 4040 0190 3c40 0090 rk......@@..<@.. 00000020: 4640 1b90 4440 0390 4240 0190 4740 00ff F@..D@..B@..G@.. 00000030: 2f4d 5472 6b00 0000 db00 905c 4001 905d /MTrk......\@..] 00000040: 4001 9059 4000 905c 4001 9058 4000 904e @..Y@..\@..X@..N 00000050: 4001 904f 4001 904b 4000 9049 4001 904a @..O@..K@..I@..J 00000060: 4001 9046 4000 904a 4001 904b 4001 9047 @..F@..J@..K@..G 00000070: 4000 9048 4001 9049 4001 904a 4001 9046 @..H@..I@..J@..F 00000080: 4000 904d 4001 904e 4001 904a 4000 904c @..M@..N@..J@..L 00000090: 4001 9048 4000 9048 4001 9044 4000 9048 @..H@..H@..D@..H 000000a0: 4001 9044 4000 9045 4001 9046 4001 9042 @..D@..E@..F@..B 000000b0: 4000 9040 4001 9041 4001 903d 4000 903b @..@@..A@..=@..; 000000c0: 4001 903c 4001 9038 4000 902f 4001 9030 @..<@..8@../@..0 000000d0: 4001 902c 4000 9027 4001 9023 4000 902a @..,@..'@..#@..* 000000e0: 4001 9031 4002 9032 4001 9037 4003 9038 @..1@..2@..7@..8 000000f0: 4001 9039 4001 903a 4001 903f 4001 9044 @..9@..:@..?@..D 00000100: 4001 9049 4001 904e 4001 9056 4001 904f @..I@..N@..V@..O 00000110: 4000 ff2f @../ This answer uses the same process as Sp3000's Prelude answer. However, since Fugue can push any integer from -10 to 10, I use the upper voice to store the constant 10 (since copying a value takes one fewer instruction than pushing a new one) and then convert from base 11. The compiler is rather old and can be tricky to use; my usual process (on x86-64 Linux) is to use the commands: gcc -Dstricmp=strcasecmp -Wno-format -o fugue_x86 fugue_x86.c xxd -r hello.bin > hello.midi ./fugue_x86 hello.midi /coffc gcc -D__cdecl= -Dfugue=_fugue -m32 -o hello hello.obj hello_wrp.c Note that this program is not a valid MIDI file due to the missing length fields after the 2F meta-events. I didn't optimize it at all for musicality, but if you still want to listen to it, here is an equivalent MIDI file: 00000000: 4d54 6864 0000 0006 0001 0002 0001 4d54 MThd..........MT 00000010: 726b 0000 001c 0090 4040 0190 3c40 0090 rk......@@..<@.. 00000020: 4640 1b90 4440 0390 4240 0190 4740 00ff F@..D@..B@..G@.. 00000030: 2f00 4d54 726b 0000 00dc 0090 5c40 0190 /.MTrk......\@.. 00000040: 5d40 0190 5940 0090 5c40 0190 5840 0090 ]@..Y@..\@..X@.. 00000050: 4e40 0190 4f40 0190 4b40 0090 4940 0190 N@..O@..K@..I@.. 00000060: 4a40 0190 4640 0090 4a40 0190 4b40 0190 J@..F@..J@..K@.. 00000070: 4740 0090 4840 0190 4940 0190 4a40 0190 G@..H@..I@..J@.. 00000080: 4640 0090 4d40 0190 4e40 0190 4a40 0090 F@..M@..N@..J@.. 00000090: 4c40 0190 4840 0090 4840 0190 4440 0090 L@..H@..H@..D@.. 000000a0: 4840 0190 4440 0090 4540 0190 4640 0190 H@..D@..E@..F@.. 000000b0: 4240 0090 4040 0190 4140 0190 3d40 0090 B@..@@..A@..=@.. 000000c0: 3b40 0190 3c40 0190 3840 0090 2f40 0190 ;@..<@..8@../@.. 000000d0: 3040 0190 2c40 0090 2740 0190 2340 0090 0@..,@..'@..#@.. 000000e0: 2a40 0190 3140 0290 3240 0190 3740 0390 *@..1@..2@..7@.. 000000f0: 3840 0190 3940 0190 3a40 0190 3f40 0190 8@..9@..:@..?@.. 00000100: 4440 0190 4940 0190 4e40 0190 5640 0190 D@..I@..N@..V@.. 00000110: 4f40 00ff 2f00 O@../. 3 # Kotlin, 33 bytes fun main()=print("Hello, World!") This is probably the shortest you can go. 1Welcome to Code Golf, nice first answer! – Redwolf Programs – 2021-02-10T15:27:55.790 3 # Actionscript 3.0, 23 22 bytes trace("Hello, World!") Does actionscript 3.0 REQUIRE semi-colons? I stopped after 2.0 but I don't think it did back then. – Albert Renshaw – 2015-09-29T21:27:28.677 1@AlbertRenshaw is correct, it doesn't require a semi-colon in 3.0. – Elliot Blackburn – 2015-10-02T14:17:47.407 This works in the Actions pane of the Flash IDE, but Flash Builder or the Actionscript compiler, you need a full class definition. – Brian – 2016-01-15T18:54:34.600 3 # FlogScript, 17 bytes {Hello, World!}P. 3 # Perl, 18 bytes say"Hello, World!" ### Remark: "say" is used in Perl 6. While "print" is a Perl 5 thing. But "say" can be used in version 5.10+ when the -M5.010 switch (or -M for a higher version) is used. ## Perl 5 without version switch, 20 bytes print"Hello, World!" ### Perl/Tk, 91 Bytes Ok, this doesn't exactly print to STDOUT as was requested by the challenge. Since it creates a window with a button. So this was just added for the sake of entertainment/completeness. use Tk;MainWindow->new->Button(-text=>"Hello, World!",-command=>sub{exit})->pack();MainLoop 1 You can shave off 2 bytes by replacing print with say, provided the OP agrees with this meta post in -M5.010 being free. – Slade – 2015-08-28T15:54:53.760 I knew "say" is used in Perl 6, but didn't realise they added it to a more recent version of Perl 5 than the one I use. So I added both to the post. – LukStorms – 2015-08-28T19:42:32.967 There is another Perl 6 answer, so maybe you could just post the Perl 5 one. – LegionMammal978 – 2015-09-01T21:41:54.100 3 # Wheat, 32 Bytes Wheat is an esolang that is based on outputting and inputting. Only what has been output on a previous cycle can be input on the current one. The buffers last only one cycle; if the data of previous cycle is not read on current cycle, on the next cycle it can not be accessed, it will all be erased, replaced by the output of the current cycle (if any, otherwise the empty string is used). output "Hello, World!" terminate 1The description of Wheat that you gave is taken directly from the Wheat esolang page. Care to cite? – Esolanging Fruit – 2018-01-21T06:41:14.270 3 # Gibberish, 17 Bytes Surprisingly, the shortest answer I could make is not gibberish at all. [Hello, World!]eo 3 # golflua, 16 bytes w"Hello, World!" 3 # VBA, 15 ?"Hello, World! Try it, for instance, in the "Immediate" panel of the development window in MS Excel. I see. I'll try Brandy – Beta Decay – 2015-08-28T15:01:13.407 Nope, returns with "Type mismatch: number wanted" – Beta Decay – 2015-08-28T15:01:50.740 @BetaDecay I can post a screenshot if you like – Jerry Jeremiah – 2015-08-30T23:05:12.833 1@edc65 This still works (least in my VBA7 version) if you remove the trailing quote saving you 1 byte: ?"Hello, World! – i_saw_drones – 2019-05-07T21:21:47.090 1@i_saw_drones amazing! VBA is really forgiving (or really a mess). Thanks for the hint – edc65 – 2019-05-08T14:15:53.590 3 # Rust, 34 bytes fn main(){print!("Hello, World!")} 3 # CJam, 15 bytes "Hello, World!" Try it online 3 # XSM, 28 bytes <print>Hello, World!</print> This is an actual XML programming language? Wow. That's... different! – galexite – 2015-08-28T17:09:53.933 1Damn it, I was hoping I could write my own... Now someone's already gone and made it :P – Beta Decay – 2015-08-29T07:12:40.380 @BetaDecay There is also http://xplusplus.sourceforge.net/ and http://www.o-xml.org/ – Jerry Jeremiah – 2015-08-30T23:15:10.647 3 # GolfScript, 15 bytes "Hello, World!" 3 # ///, 13 Hello, World! can't get much simpler than this 3 # Underload, 16 bytes (Hello, World!)S Underload is the Brainfuck of stack-based languages. (x) pushes the string x to the stack, and S prints the value on top of the stack. 3 # Rail, 27 bytes$'main'
-[Hello, World!]o#

Rail is a 2D language where the instruction pointer is a train that runs on, well, rails. Execution begins from the main function, starting from the $and initially moving southeast. The first command encountered is -, which makes the train turn so that it's moving eastward. Then we push a string, output with o and terminate with #. 3 # bc, 16 bytes "Hello, World!" (bc requires a trailing newline - hence 16 instead of 15) 3 # Sinclair BASIC, 16 bytes PRINT "Hello, World!" Note: PRINT on the Sinclair Spectrum is written with a single keystroke (p) and takes a single byte. The code above works on the "command line". You can try it online at http://torinak.com/qaop. Keystrokes for that emulator: p shift-' shift-h e l l o , space shift-w o r l d ctrl-1 shift-'. Don't press shift-1 as that seems to delete the whole line. Depending on your definition of a "full program", this may or may not be acceptable. Especially for bigger programs, you would need to use line numbers, type the whole program and then use the RUN command (keystroke r). In that case, prepend a 1 to the above code (for 1 extra byte). 3 # Idris, 36 bytes main:IO();main=putStr"Hello, World!" Idris is sort of like Haskell, but top-level definitions need a type signature. Also, it has dependent types and is a way better language xD – univalence – 2018-11-06T17:34:24.800 3 # CoffeeScript, 21 bytes alert "Hello, World!" or console.log "Hello, World!", if that's closer to STDOUT for your tastes. 3 # pb, 80 bytes b[72]>b[101]>b[108]>b[108]>b[111]>b[44]>>b[87]>b[111]>b[114]>b[108]>b[100]>b[33] Super naive. I tried to golf it down by keeping 108 (the character code for "l") in T, either by doing t[108] at the beginning of the program or t[B] after the first time it was printed, but each attempt ended up exactly the same length. Note that pb doesn't require you to write b[32]. Any blank spaces on the canvas (with at least one non-blank space to the right of it) are automatically printed to the terminal as a space. 3 # Fueue, 47 bytes 72 101 108 108 111 44 32 87 111 114 108 100 33H 3 # 99, 283 bytes 999 9 9 99 99999999 999 9 99 99 99999 9 999 9 99 99 99 999 999999 99 99 99 9999999 9999 999 9 99 99 99 9999999 9 999 9 999 9 999 9 99 99 99 999999 9 999999 9 99 9999 99 99999 999 999999 999 9 99 99 9999999 9999 9 999 9 99 99 99 999999 9 99 99 99 999999 999 9 99 99 99999 9999999 9 99 This was handcrafted so it is very likely suboptimal. Someone should write a metagolfer... The following table has been quite useful writing 99 code by hand: Variable /9%128 Can print? 9 1 99 11 ! 999 111 9999 87 ! 99999 103 999999 7 ! 9999999 71 99999999 71 ! All further rep-digits of 9 also yield 71 when taken modulo 128 (after dividing by 9). All further rep-digits of 9 also yield 71 when taken modulo 128. you can't just drop these math facts like they're nothing.now i'm going to be amazed all day – undergroundmonorail – 2015-08-30T14:04:26.547 @undergroundmonorail Note that it's actually the rep-digits of 1 which do this, because the variable is divided by 9 before taking the modulo. And the reason this works is that (710 % 128) happens to be 70. – Martin Ender – 2015-08-30T14:09:39.427 3 ## 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 – 2015-08-31T15:21:54.123 1Is the plz necessary? I thought you could just console.loge. – Alex A. – 2015-09-02T05:59:32.993 @AlexA. doesn't work without plz in the online interpreter, in accordance with the specs – kvill – 2015-09-02T19:56:29.867 That's what I was thinking... – LegionMammal978 – 2015-09-03T10:57:31.560 3 # KEMURI, 65 bytes ^^^^"^^'"'^'"'"^^^^'^''^"^^^^^^''^'"''"^^^^^^^'"^^'^'^''^'^'^| There's a KEMURI to C compiler available here if you'd like to test. KEMURI is stack-based, and has the following 6 instructions: ~ Pop byte and push its NOT ^ Pop two bytes and push their XOR " Duplicate top of stack ' Rotate top three of stack (top becomes third)  Push the ASCII values of "Hello, world!" | Output stack as ASCII Note that  pushes "Hello, world!" with a lowercase w. This means that the shortest "Hello, world!" program is | but that doesn't mean that the best "Hello, World!" program, with an uppercase w, will be particularly short. To aid our search for the best "Hello, World!", here are a couple of observations: • | empties the stack, so we will only need it exactly once, as the very last character in the program. • ~ is useless, since NOT will flip the most significant bit to 1, which no printable ASCII character needs. • We will never need to duplicate with " if the top two stack elements are the same, since: • Rotating three identical elements is a no-op. • The only way to reduce the stack size is with ^ XOR. XOR of two identical elements just introduces a 0 and XOR 0 is a no-op. • "Hello, World!" contains neither a triple letter nor ASCII 0. This means that we only need to look at the four instructions ^"'. To piece together the "Hello, World!", I looked at programs which contain a single , at the very start. This gives a bunch of "jigsaw pieces" which we can fit together to form the whole message. There's no guarantee that this approach is optimal, but the search space is pretty big, so any better solution will probably need to be a bit more intelligent. The pieces I managed to obtain were (<sp> is trailing space): World! ^^^^^"^^^| orld! ^^^^^^^"^^| rld! ^^^^^^^^"^^| ld! ^^^^^^^^^"^^| d! "^^^^^^^^^^^^| World! ^^^^^"^'"'^'^| <sp> ^"^^^^^^^^^^^^| ! ^^^^^^^^^^^"^^| H ^^^^^^^^^^'^"^^| , ^^^^^^^^^^''"^^^| d ^^^^^^^^^^''^"^^| o ^^^^''^"^^^^^^^^| e "^^^^^^'"^^^^^^^^| W ^"^^^^^^'"^^^^^^^| l ^^"^^^^'"^^^^^^^^| , World! ^^^^"^^'"'^'"'"^^| ld ^^^^^^^^^"^^''"^^| ll ^^"^^^^'"^^^^^^^^"| r ^^^^^^'"^^^^'^"^^^| rl ^^^^^^'"^^^^''"^^''^| He ^^^^^'"^^'^'^''^'^'^| el ^^"^^^^^^^^''"^^''"^^| o, ^^'^"^^^^"'^'^'^'^'^'^| Wo ^^^^"^^^'"^^'^''^''^''^| ,<sp> ^^^^^'^'^'^''^''^'"'^'^| lo ^^^^^^^"^^'"^^''"^^''"^^| or ^^^^^^'^"^^''"^^''"^^''^| llo ^^'^''^"^^^^^^''^'"''"^^| ell ^^"^^^^^^^^''"^^'"''"^^''| W ^"^^^^^^''^''^''^''^''^"'^| The program at the top of the post was formed by combining the He, llo and , World! pieces. 3 # Aheui, 177 bytes 밣밢따빠빠빠맣밤밢따다빠빠빠밠타맣맣맣받다맣밠밤따타맣밤밣따맣받발따다빠맣밦밤따다빠빠맣받다맣받타빠맣밣타빠맣받나맣희 Aheui is Befunge, but with Hangul. Test this here. 3 # MicroSoft Windows HTA - 13 bytes Hello, World! MicroSoft Windows HTA occupies a niche between HTML and applications, where you get the simplicity and ease of HTML, with the direct access to the system API of applications, including file and system calls. When I was first introduced to it, I wondered how I ever got along without it. I used it to make really easy intuitive interfaces for complex command line utilities. Sadly, it's fallen by the wayside and you hardly hear about it anymore. One thing I remember about the official documentation was that they boasted how a bare Hello, World! is a legal hypertext application. 3 # Swift, 22 Bytes ### Before Version 2.0 (24 Bytes) println("Hello, World!") ### After Version 2.0 (22 Bytes) print("Hello, World!") Includes trailing newline Top level code in the main file gets executed automatically. In playgrounds, anything at top level gets executed as well. In version 2.0 beta 6 this is also possible: print("Hello,", "World!") which will print all the items provided, separated by a space, terminated by a newline. This is equal to the following (which is probably the longest Swift version of a non-ridiculous "Hello, World!" program): print("Hello,", "World!", separator: " ", terminator: "\n") Since version 2.0 beta 6, Swift is one of the few languages that can have a vararg parameter at any position (not just the end), due to named parameters. 3 # Beam, 128 120 Bytes '''''''''>++++++++)@'''P''''>++++)+@+++++++@P@+++@'P'L'''>++++++)''P'>++++)@''p@'p>+++++)@'p@+++@p@--------@''p+@H This uses the general construct: ''''''''' # increment store to 9 > # set direction right. Beginning of loop  # decrement store ++++++++ # increment beam 8 ) # set direction left if store not 0. End of loop @ # Output character Effectively translates to 9 * 8. The store needs to be odd before entering the loop otherwise it will end up being an infinite loop. The Esolangs has examples of this at the bottom in the constants section. P is used to save to l, o and memory slots 0, 1 and 2. p is used to retrieves those values to the beam. The following snippet should run Beam programs, but it hasn't been put through the ringer yet, so is likely to have some bugs. var ITERS_PER_SEC = 100000; var TIMEOUT_SECS = 50; var ERROR_INTERRUPT = "Interrupted by user"; var ERROR_TIMEOUT = "Maximum iterations exceeded"; var ERROR_LOSTINSPACE = "Beam is lost in space"; var code, store, beam, ip_x, ip_y, dir, input_ptr, mem; var input, timeout, width, iterations, running; function clear_output() { document.getElementById("output").value = ""; document.getElementById("stderr").innerHTML = ""; } function stop() { running = false; document.getElementById("run").disabled = false; document.getElementById("stop").disabled = true; document.getElementById("clear").disabled = false; document.getElementById("timeout").disabled = false; } function interrupt() { error(ERROR_INTERRUPT); } function error(msg) { document.getElementById("stderr").innerHTML = msg; stop(); } function run() { clear_output(); document.getElementById("run").disabled = true; document.getElementById("stop").disabled = false; document.getElementById("clear").disabled = true; document.getElementById("input").disabled = false; document.getElementById("timeout").disabled = false; code = document.getElementById("code").value; input = document.getElementById("input").value; timeout = document.getElementById("timeout").checked; code = code.split("\n"); width = 0; for (var i = 0; i < code.length; ++i){ if (code[i].length > width){ width = code[i].length; } } console.log(code); console.log(width); running = true; dir = 0; ip_x = 0; ip_y = 0; input_ptr = 0; beam = 0; store = 0; mem = []; input = input.split("").map(function (s) { return s.charCodeAt(0); }); iterations = 0; beam_iter(); } function beam_iter() { while (running) { var inst; try { inst = code[ip_y][ip_x]; } catch(err) { inst = ""; } switch (inst) { case ">": dir = 0; break; case "<": dir = 1; break; case "^": dir = 2; break; case "v": dir = 3; break; case "+": ++beam; break; case "-": --beam; break; case "@": document.getElementById("output").value += String.fromCharCode(beam); break; case ":": document.getElementById("output").value += beam+"\n"; break; case "/": switch (dir) { case 0: dir = 2; break; case 1: dir = 3; break; case 2: dir = 0; break; case 3: dir = 1; break; } case "\\": switch (dir) { case 0: dir = 3; break; case 1: dir = 2; break; case 2: dir = 1; break; case 3: dir = 0; break; } break; case "!": if (beam != 0) { switch (dir) { case 0: dir = 1; break; case 1: dir = 0; break; case 2: dir = 3; break; case 3: dir = 2; break; } } break; case "?": if (beam == 0) { switch (dir) { case 0: dir = 1; break; case 1: dir = 0; break; case 2: dir = 3; break; case 3: dir = 2; break; } } break; case "|": switch (dir) { case 0: dir = 1; break; case 1: dir = 0; break; } break; case "_": switch (dir) { case 0: dir = 1; break; case 1: dir = 0; break; } break; case "H": stop(); break; case "S": store = beam; break; case "L": beam = store; break; case "s": mem[beam] = store; break; case "g": store = mem[beam]; break; case "P": mem[store] = beam; break; case "p": beam = mem[store]; break; case "u": if (beam != store) { dir = 2; } break; case "n": if (beam != store) { dir = 3; } break; case "": --store; break; case "'": ++store; break; case ")": if (store != 0) { dir = 1; } break; case "(": if (store != 0) { dir = 0; } break; case "r": if (input_ptr >= input.length) { beam = 0; } else { beam = input[input_ptr]; ++input_ptr; } break; } // Move instruction pointer switch (dir) { case 0: ip_x++; break; case 1: ip_x--; break; case 2: ip_y--; break; case 3: ip_y++; break; } if (running && (ip_x < 0 || ip_y < 0 || ip_x >= width || ip_y >= code.length)) { error(ERROR_LOSTINSPACE); } ++iterations; if (iterations > ITERS_PER_SEC * TIMEOUT_SECS) { error(ERROR_TIMEOUT); } } } <div style="font-size:12px;font-family:Verdana, Geneva, sans-serif;">Code: <br> <textarea id="code" rows="3" style="overflow:scroll;overflow-x:hidden;width:90%;">'''''''''>++++++++)@'''P''''>++++)+@+++++++@P@+++@'P'L'''>++++++)''P'>++++)@''p@'p>+++++)@'p@+++@p@--------@''p+@H</textarea> <br>Input: <br> <textarea id="input" rows="2" style="overflow:scroll;overflow-x:hidden;width:90%;"></textarea> <p>Timeout: <input id="timeout" type="checkbox" checked="checked">&nbsp; <br> <br> <input id="run" type="button" value="Run" onclick="run()"> <input id="stop" type="button" value="Stop" onclick="interrupt()" disabled="disabled"> <input id="clear" type="button" value="Clear" onclick="clear_output()">&nbsp; <span id="stderr" style="color:red"></span> </p>Output: <br> <textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea> </div> 3 # Commodore Basic, 16 bytes In order to input this program, you'll need to switch your Commodore 64 to character set 2 by pressing <SHIFT> + <C=>. 1?"hELLO wORLD! The Commodore home computers come with two character sets: "unshifted" mode, which is derived from ASCII-1963 and so lacks lower-case letters, and "shifted" mode, which has both lower- and upper-case letters, but in the opposite order from modern ASCII-1967-derived encodings. Any "Hello, World!' program that produces the requested byte stream on a Commodore will look funny on the Commodore's screen. In the interests of not having to look up a half-dozen obscure Unicode characters, I've chosen to write my program in "shifted" mode, which merely has reversed case. As a side note, the Commmodore Basic interpreter (and presumably many other Microsoft Basic variants) will let you omit the trailing quotation mark if a string extends to the end of the current source line. 3 ## Simplex, 16 bytes "Hello, World!"g g is the standard output mechanism. 1Thanks for using Simplex :D – Conor O'Brien – 2015-10-26T11:21:15.987 3 ## 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 – 2016-01-20T22:56:05.510 Ah. Sorry, didn't realize :P – a spaghetto – 2016-01-20T23:45:14.360 Maybe the scoreboard snippet should be updated. – mbomb007 – 2016-01-22T17:58:24.297 3 # 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. 3 # 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! 3 # 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. 3 # 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!"); 3 # 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. 3 # Verilog, 60 bytes module m;initial begin$write("Hello, World!");end
endmodule

The initial block doesn't need begin & end. – ahmedus – 2020-06-22T22:46:16.373

3

# 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 – 2016-03-25T23:56:31.067

3

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

3

## Kotlin, 50 48 bytes

fun main(a:Array<String>)=print("Hello, World!")

3

## Commercial, 75 bytes

I post a link to my implementation, but there is a link to the esolang page in the README

"Hello, World!" - Satisfied Consumer of x
x has been selling out worldwide!

This code is equivalent to the following pseudocode

Put "Hello, World!" in x
Print the value of x

like the theme lol – Rohan Jhunjhunwala – 2016-09-16T01:16:38.830

3

# 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 – 2016-09-23T03:09:16.370

@DestructibleWatermelon Oh yeah, that's because I stopped working on Pyramid. – clismique – 2016-09-23T06:40:36.847

3

# 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 – 2018-04-13T04:31:00.623

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 – 2018-04-13T04:36:43.797 Here's a 30-byte version https://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 – 2018-04-13T04:46:18.700 *window subsystem for linux – ASCII-only – 2018-04-17T11:10:11.043 3 # 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. 3 # Codelike, 127 bytes on++++++++n+++n+++**pn++++n+++++++*+ap+++++++pp+++pn++++n++++++++*pfn++n++++*ap________p+++p______p________pn++++n++++++++*+pfe Try it! 2 # TI-83 Hex Assembly, 21 bytes PROGRAM:H :AsmPrgm219C9DEF0A45C9 :48656C6C6F2C20576F726C642100 Run it with Asm(prgmH). First line is code section, 2nd line is data section. I count each pair of hex digits as one byte. 2 # stacked, 18 bytes 'Hello, World!'out Try it here! Introducing my newest creation, stacked! It's a stack based language. Creative, I know. But this pushes 'Hello, World!' to the stack the outputs it. Simple enough! 2 ## WSF, 223 bytes Stack Exchange cannot display this code properly, so here is a reversible xxd hexdump: 00000000: 2020 2020 2020 2020 2020 2020 2020 2020 00000010: 2020 2020 0a20 200a 2020 2020 2020 2020 . . 00000020: 2020 2020 2020 200a 2020 2020 2020 2020 . 00000030: 2020 2020 2020 2020 2020 2020 200a 2020 . 00000040: 2020 2020 200a 2020 0920 0920 0920 0920 . . . . . 00000050: 2009 0a09 200a 2020 2020 0909 200a 2020 ... . .. . 00000060: 0909 2020 2020 2020 2020 2020 2020 2020 .. 00000070: 0909 0909 2020 2020 2020 0909 200a 2020 .... .. . 00000080: 2020 0909 0920 0920 2020 2020 2020 2020 ... . 00000090: 2020 2020 2020 2020 2020 2020 2020 2020 000000a0: 2020 2020 2020 0909 200a 0909 2020 2020 .. ... 000000b0: 2020 0909 2009 2009 2009 2009 2009 2009 .. . . . . . . 000000c0: 0909 2009 2009 2009 2009 2009 2009 2009 .. . . . . . . . 000000d0: 2009 0909 200a 2020 0909 200a 0909 0a ... . .. .... Ruby inspected string: " \n \n \n \n \n \t \t \t \t \t\n\t \n \t\t \n \t\t \t\t\t\t \t\t \n \t\t\t \t \t\t \n\t\t \t\t \t \t \t \t \t \t\t\t \t \t \t \t \t \t \t \t\t\t \n \t\t \n\t\t\n" There's a 174 byte one on TIO – ASCII-only – 2017-08-21T12:16:28.950 2 # Befunge-93, 21 bytes "!dlroW ,olleH">:#,_@ Try it online! Explanation "!dlroW ,olleH" Push the string onto the stack in reverse. Note that there is an implicit null terminator since an empty stack will always pop zero. > Start the output loop. : Duplicate the character at the top of the stack. # Skip the following operation to the right. _ Test if the character is null, dropping the duplicate copy. , If not, branch left and write the character to stdout. # Skip the following operation to the left. > Reverse direction and repeat the loop with the next character. @ Once the null is reached, branch right and exit. 2 # Del|m|t, 29 + 1 = 30 bytes Try it online! =#:#Hello, World!#/#2#>#?#9#" ...With # passed as a command line argument. This is a new language that I recently created, which uses regex to parse its source code. I highly recommend that you read the documentation and tutorial. Explanation: The regex passed as an argument acts as a delimiter (hence the name), which parses the code into tokens, which are read as commands based on their ASCII values. Because the regex is #, the tokens are =, :, Hello, World!, /, 2, >, ?, 9, and " These correspond to commands depending on their ASCII values mod 32: (=) 29 29 pops the top value of the stack, and skips that many instructions. Right now, the top is 0, so it's a no-op. Later, we will use it to skip the following part that pushes the string (:) 26, (H...) "H..." 26 pushes the next token as a string backwards onto the stack (/) 15 Duplicates the top of the stack, so we have 2 copies of the top character. (2) 18 Nots the top of the stack. It the top was 0, it is now 1 (>) 30, (?) 31 Iff the top of the stack is non-0, exit the program (9) 25 Print the character (") 2 Push 2 - This is used to skip the String pushing part when we... Go back to the start of the program and repeat 2 # SmileBASIC, 15 bytes ?"Hello, World! ? is a shorthand for PRINT, which is of course always at least 4 characters shorter and never needs whitespace before or after it. In addition, strings which run to the end of the line don't need the closing ". It's supposed to print an uppercase W (even though it's in the middle of the sentence...) – 12Me21 – 2017-02-01T20:49:28.467 2 # Taxi, 184 bytes "Hello, World!" is waiting at Writer's Depot.Go to Writer's Depot:w 1 r 3 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:e 1 r 2 r 1 l.Go to Taxi Garage:n 1 r 1 l 1 r. Try it online! When golfing in Taxi, is it strictly necessary to return to the garage after the post office? Officially, the program isn't successful unless you end in the garage but it still prints on Tio Nexus. I don't know what happens using the C++ interpreter from github. If it's not required, dropping it saves 32 bytes. – Engineer Toast – 2017-03-22T19:28:56.550 1@EngineerToast The challenge specification specifically says there can't be any STDERR output, while if you don't return to the garage, it says something along the lines of being fired from your position as a taxi driver because you didn't return the car at the garage. Try removing Go to Taxi Garage.... and then click on "Debug" to open STDERR output + TIO debug output, then run the program. – Erik the Outgolfer – 2017-03-23T12:43:59.900 Ah, good point; I overlooked that. Thank you for explaining it so completely for the novice that is me. It's something I plan to use in other Taxi golfing, though, bolstered by a meta post that discusses it. – Engineer Toast – 2017-03-23T22:47:59.383 You can remove the space after the quote – ASCII-only – 2017-08-23T06:55:54.933 2 # Valyrio, 17 bytes s ∫ main [´Ø] and start and end comments. s ‹Sets the mode to stack mode, usually used for code golf as its shorter› ∫ ‹Tells the interpreter that the previous letter was a tag, not a command› main [ ‹Starts the main code block› ´ ‹Pushes "Hello, World!" in unicode numbers to the stack (Alt-Shift-E on Mac)› Ø ‹Outputs the stack as unicode characters› ] ‹Ends the main code block‹ 2Nope. It's 17 bytes. – TuxCrafting – 2017-02-04T22:43:50.537 2No, not 13 bytes. 17 bytes. The interpreter recieves a file as UTF-8 bytes, of which there are 17, it doesn't matter how it tokenises those bytes. This is opposed to, e.g. TI-Basic which has a character encoding that really does represent multiple characters with one bytes. – Pavel – 2017-02-04T22:44:05.313 Oh. Didn't realise it worked that way, I'll change it. – None – 2017-02-04T22:44:47.667 Also why downvote simply because I didn't understand string encoding? Seems a little mean. – None – 2017-02-04T22:47:23.040 @JackBates reading the readme on GitHub, I noticed that Valyrio includes a "code-golf" mode, in which every builtin is a byte. How does that work? – Pavel – 2017-02-04T23:11:27.020 That was in the above confusion. I'll remove it from the code – None – 2017-02-04T23:12:36.563 Is there a 6-byte file you can pass to the interpreter to print Hello World? If there is, you can claim a score of 6 bytes. – Dennis – 2017-02-04T23:38:42.500 Not in UTF-8 but I'm not sure about other encodings. s ∫ main [ is needed to prefix all stack mode languages so... – None – 2017-02-04T23:41:28.547 2 # Commodore 64/128/VIC-20 & others (BASIC) (21 bytes 20 bytes): 0 PRINT"HELLO, WORLD! # Commodore 64/VIC-20 (assembly) using the Kernal** (27 bytes assembled): *=$033c
ldx #$00 loop lda message,x jsr$ffd2
inx
cpx #$0d bne loop rts message .text "hello, world!" Once assembled (and loaded into memory), call with sys 828 ** Yes, I know. Don't use the Kernal (probably also works in 128 native mode, I can't remember). Might be able to save a few bytes by counting the X index to zero if you reverse the string, like this [untested]: *=$033c ldx #$0c loop lda message,x jsr$ffd2 dex bne loop rts message .text "!dlrow ,olleh" – Shaun Bebbers – 2017-02-13T09:07:28.090

2Somehow I could 22 bytes in the basic solution, also 0?"HELLO, WORLD!" should work for 17 bytes. – NieDzejkob – 2017-04-29T17:25:31.927

1You know, you don't actually have to include the line numbers for the program to work. PRINT"HELLO, WORLD!" for 20 bytes will do fine. – MD XF – 2017-05-07T21:28:33.027

1Also, if Commodore 64 BASIC is like most old BASIC implementations (which I'm pretty sure it is) you could leave off the ending quote altogether. – MD XF – 2017-05-07T21:29:06.290

@NieDzejkob - using Commodore BASIC abbreviations does not save any bytes in the computer, it only saves typing. – Shaun Bebbers – 2017-05-08T14:43:00.280

@MDXF Unless you are doing a straight character count, rather than how much actual bytes you are using of the available free memory, then you are correct. However, without a line number, it is more difficult to say how much memory is being used as you're running in direct mode rather than keeping an executable symbolic listing in memory. – Shaun Bebbers – 2017-05-08T14:45:05.793

2

## Hillberth, 32 bytes

[]H ,olH
.<   Wle
ro
ld!

If this code is weird looking, it's because the flow of an Hillberth program follows an Hilbert curve. So, the executed program is this:

[.<]H                                              !dlroW ,olleH

The code is similar to a Self-Modifying BrainFuck code, with the H command stopping the program.

2

# KanyeC, 78 bytes

"A programming language based on the brilliance of Kanye West."

I am the greatest
make her say "Hello, World!"
I still think I am the greatest

Yes, it is essentially just an ArnoldC substitution, but I thought I'd contribute it for the sake of completeness.

2

# HODOR, 2384 bytes

Walder
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
HODOR!
Hodor Hodor Hodor
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
HODOR!!!

I decided that my NO! answer wasn't long enough so I finished my commemoration of Hodor and spend a while coding this.

Hodor uses an accumulator because he's learning to count and can't remember more than 1 number.

In short (because I'm not doing a line-by-line explanation) these are the main commands:

Walder Hodor hodor hodor hodor Hodor hodor hodor hodor

Start the program because Hodor's original name was Walder

Hodor Hodor hodor hodor hodor hodor

Hodor! Hodor hodor hodor hodor hodor

Subtract 1 from the accumulator

HODOR! Hodor hodor hodor hodor hodor hodor hodor

Output the accumulator as a Unicode character

HODOR!!! Hodor Hodor (Hodor hodor hodor)

Kill Hodor (End the program)

Dammit hodor, why? – Matthew Roh – 2017-04-04T06:28:06.553

You should answer this with HODOR: http://codegolf.stackexchange.com/questions/48907/hodorize-a-string

– Malivil – 2017-04-05T17:08:03.743

2

# Turing, 18 bytes

put"Hello, World!"

Is this the correct github page? https://github.com/Open-Turing-Project/OpenTuring

– mbomb007 – 2017-04-07T21:07:14.887

Welp, I'm blind. – Daniel F – 2017-04-07T21:11:49.323

2

# Charcoal, 13 bytes

Hello, World!

Charcoal prints the canvas state at the end of execution, and any run of ASCII characters is considered a string, which is implicitly printed to the canvas.

2

# Braingolf, 17 bytes

Got bored, made my own language, here's Hello World

"Hello, World!"&@

Explanation:

"Hello, World!"    Push the 13 chars of Hello World to the stack as charcode integers
&@  Pop the entire stack and print as chars

Alternatively, here's hello world from before I added multi-char strings and printing:

#!#d#l#r#o#W# #,#o#l#l#e#H@@@@@@@@@@@@@

Explanation:

#!                                 Push the charcode of char '!' to the end of the stack
....................             Do this for every character in "Hello, World!" in reverse order
@@@@@@@@@@@@@  Pop and print the last element of the stack 13 times

>

• outdated, 2. doesn't even print the right Hello, World!
• < – ASCII-only – 2017-08-23T06:27:49.620

@ASCII-only fixed – Skidsdev – 2017-08-23T08:20:22.433

2

# MY, 1 byte.

Here is the hex:

FF

I'm finally ready to reveal my language. It's still a major WIP, and the undefined byte meaning is temporary (except for maybe 0xFF). I will eventually update this to include a non-hacky solution when MY is able to do that.

I did add another solution, this time not relying on a built-in! https://codegolf.stackexchange.com/questions/55422/hello-world/127294#127294

– Zacharý – 2017-06-19T20:51:27.810

2

SASS, 32 bytes?

\:after
content:"Hello, World!"

2

# Klein, 16 + 3 = 19 bytes

"Hello, World!"@

• +3 for -A flag
• Also contains a null argument for the topology, I'm not even sure how to score that.

Try it online!

Competing for the bounty.

4

Not competing for the bounty, Wheat Wizard stated in chat that he wouldn't award it to those using " (otherwise this would be a trivial bounty).

– Okx – 2017-05-19T06:18:52.793

2

## StupidScript, 214 bytes

It's a joke language that I just made. Mark Watney would be proud.

80.5 0.0
80.5 23.0
69.0 103.5
69.0 161.0
80.5 46.0
23.0 0.0
23.0 23.0
46.0 92.0
69.0 57.5
69.0 138.0
69.0 138.0
69.0 172.5
23.0 138.0
23.0 0.0
57.5 80.5
69.0 172.5
80.5 23.0
69.0 138.0
69.0 46.0
23.0 11.5
23.0 23.0

2

# Fishing, 25 24 bytes

[+_
|C]Hello, World!Ni

It exits with an error.

# Fishing, 34 bytes

v+CCCCCCCC^]
Hello,
N!dlroW

Without errors.

2

# Neim, 16 bytes

(Hello, World!)B

Try here

Made possible thanks to (partial) BigInteger support.

2

# Lean Mean Bean Machine, 55 bytes

OOOOOOOOOOOOO
"""""""""""""
Hello, World!
!!!!!!!!!!!!!

I think this is the shortest.

Here's a somewhat more entertaining alternative approach in 96 bytes:

OOOOOOOOOO
"""
Hel
!!!""""
!o, W
!!!!

!   "
r
!""
!     d!
!!

This one only sets 1 marble to each letter, and re-uses the l and o marbles, much less golfy, but more true to the spirit of the language.

2

# Emoji, 23 24 bytes

Hello, World!➡

Should be pretty clear. Just pushes Hello, World! and than outputs.

2

# Shtriped, 239 bytes

e n
e b
i b
+ x y
+
i x
d y
+
+
d x
0
+ b b b
1
+ b n n
0
z x
d x
z x
D
1
s n
z n n
z b b
i b
Y
0
0
Z
1
Y
Y
B
0
1
1
Z
1
Y
1
Y
D
B
B
1
0
Z
Y
D
B
1
Y
B
0
Z
D
1
B
B
Y
1
0
D
Y
1
1
Y
B
Z
D
B
Y
1
0
Z
Y
D
B
1
1
1
1
B
0
D

Try it online!

This Hello, World! in Shtriped terminates somewhat quickly, since it doesn't encode the entire string in one number.

2

# Set, 123 bytes

set ! H
set ! 101
set ! 108
set ! 108
set ! 111
set ! 44
set ! 32
set ! 87
set ! 111
set ! 114
set ! 108
set ! 100
set ! 33

Needed to use raw ASCII codes because lowercase letters are reserved for variable names.

Try it online!

Wow, someone actually used this language. I'm both surprised and very happy – Matheus Avellar – 2017-08-10T01:58:45.357

1

@MatheusAvellar If you haven't yet noticed it has been used in the largest polyglot in existence.

– MD XF – 2017-08-10T03:55:36.847

I had no idea! That's the coolest! Hahaha – Matheus Avellar – 2017-08-10T09:05:35.330

You can use W instead of 87 – ASCII-only – 2018-04-11T09:13:41.260

@ASCII-only but the bytecount is 123 – MD XF – 2018-06-18T21:22:26.603

@MDXF :|||||||| – ASCII-only – 2018-06-18T22:50:51.787

2

# MY, 60 bytes

27á'←1Aá'←8Aá'2×←1Bá'←44á'←2Ġ'←78á'←1Bá'←4Bá'←8Aá'←AȦ'←33á'←

MY IS ON TIO!!

## How?

Outputs H, e, ll, o, <space>, W, o, r, l, d, ! to the console.

I created a 3rd answer to this question due to the differing techniques used, this uses concatenation on numbers (27á pushes 72), one uses increment and decrement, while another uses a builtin.

2

.-$"Hello, World!" Try it online! 2 # DOBELA, 214 bytes ,,.,,,,.,..,,.,,,..,..,,,...,,.,,..,....,.,.,...,,.,,,,,,,.,..,,,..,....,..,..,,,..,..,,,..,,.,.,.,,.,,,$^
.                                                                                                         #

!        d        l        r        o        W                 ,        o        l        l        e        H
$./helloworld.xan.o Link to interpreter no longer works – ASCII-only – 2018-12-26T00:01:16.453 @ascii-only fixed – NoOneIsHere – 2018-12-26T00:38:12.713 2 # Clam, 15 bytes p+[[ua+ua,]"!"] Try it online! Oh boy, he did it again, he started another language. ## Explanation All functions and operators in Clam are prefix p+[[ua+ua,]"!"] p Print + Addition [...........] Argument list [......] Standalone list u Uppercase the first letter of.. a ..the string at dictionary index.. + ..42 (+) - 32 = 10, dictionary[10] = 'hello' ua, Do the same as above for index 11, 'world' End of list, standalone list concatenates its contents as strings with ', ' as delimiter "!" String literal End of argument list, Addition also acts as string concat Transpiled JS code: console.log('Hello, World' + "!"); 2 ## Incalculate (2.0), 21 bytes "!dlroW ,olleH"[pov?] Probably won't get shorter than this. Incalculate is an esoteric language I have written for fun, don't expect anything fancy. It uses 3 stacks for storage. 2 # Visual Basic Script, 21 bytes MsgBox"Hello, World!" You can try it by making a .txt file with that text in it, changing the extension to .vbs and running it. 1 Welcome to the site! As this is a very busy question, you should be aware that your answer may not be unique. However, it is just as valid either way. Would it be possible to edit in a link to an online testing site, such as Try it online! so that others can verify your answer? – caird coinheringaahing – 2019-08-29T14:50:34.897 2 # Simula (cim), 24 bytes OutText("Hello, World!") Try it online! Over 750 answers and we can still find languages not yet submitted. Wowsers. 2 # Intcode Since Advent of Code will inevitably be adding more features to Intcode as this year's event progresses, I'll just treat the separate revisions as different languages, and add to this if a new one makes it shorter. ## Day 2, N/A Bytes Having no real way of outputting multiple values yet, the version in day 2 can't do a proper Hello World. There is technically this 42-byte solution, but it feels like cheating because I'm pretty sure no interpreter can run it: 1,3,5,0,99,5735816763073854918203775149089 This program copies that really long number to memory location 0 (which counts as output) and then halts. The really long number happens to be Hello, World! when read in bigendian form as a string. ## Day 5, 89 Bytes In day 5, dedicated I/O instructions are added, so a proper Hello World is possible. The ability to use immediate values doesn't hurt either. 104,72,104,101,104,108,4,5,104,111,104,44,104,32,104,87,4,9,104,114,4,5,104,100,104,33,99 2 ### Java, 82 bytes: class Main{public static void main(String[]a){System.out.print("Hello, World!");}} 1@JoKing I think it's intended to be some kind of proof of the length - "look, it really is 82 bytes!" - but of course you could trivially verify the byte count by copy-pasting it into a text editor, so I agree that it's unnecessary. – F1Krazy – 2019-12-06T11:12:48.460 2 # Wren, 29 bytes System.print("Hello, World!") Try it online! ## Explanation System.print( ) // Output the following string: "Hello, World!" // "Hello, World!" 2 # Intcode, 83 72 70 bytes 204,8,109,1,1205,8,0,99,72,101,108,108,111,44,32,87,111,114,108,100,33 Try it online! Old 83 byte version: 1106,0,17,72,101,108,108,111,44,32,87,111,114,108,100,33,0,204,3,109,1,1205,3,17,99 Consider a TIO link using your own interpreter for now? like so – Value Ink – 2019-12-27T02:30:54.803 @ValueInk Done. – pppery – 2019-12-27T02:31:58.917 2 ## tq, 15 bytes "Hello, World!" Pretty much just defines a list with the only item as the string "Hello, World!". 2 ## KRC, 17 bytes This defines a function returning the string "Hello, World!". No trailing newline because it's shorter. (I've made a repl.it for KRC.) f="Hello, World!" Demo:$ ./krc demo/hello
Kent Recursive Calculator 1.0
revised 2016.03.31
/h for help
krc> f!
Hello, World!krc>

2

# ><>, 25 bytes

!v"!dlroW ,olleH"!
o>l?!;

Try it online!

My second answer in this language so far, started learning only today, thought this would be a good starting point

2

w

Try it online!

2

# evil, 70 bytes

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Try it online!

1

Just in case you missed it, there is a shorter evil solution, posted by my pronoun is monicareinstate 2 months ago.

– manatwork – 2020-06-19T00:36:17.187

@manatwork oh whoops. does that mean I should take this down? – AdamS – 2020-06-19T12:37:15.713

No, there is nothing against such solutions. Mentioned it more as fun fact. – manatwork – 2020-06-19T15:51:15.543

1

Actually I also missed the relevant one: grc posted this exact evil solution 4 years 6 months ago. ☹

– manatwork – 2020-06-21T02:47:08.310

2

# Jsonnet (with -S), 15 characters

"Hello, World!"

(Where -S stands for --string, meaning “Expect a string, manifest as plain text”.)

Sample run:

bash-5.0\$ jsonnet -Se '"Hello, World!"'
Hello, World!

2

# riscv32 and riscv64 (little endian) machine language for Linux, 38 bytes

0x00:       4505                    li      a0,1  ; Set fd=1
0x02:       012005ef                jal     a1,14 ; jmp and put ret addr in a1
0x06:       6c6c6548                              ; "Hello, World!\0"
0x0a:       57202c6f
0x0e:       646c726f
0x12:       0021
0x14:       4635                    li      a2,13 ; length of string
0x16:       04000893                li      a7,64 ; select write() syscall
0x1a:       00000073                ecall         ; call write()
0x1e:       05d00893                li      a7,93 ; select exit() syscall
0x22:       00000073                ecall         ' call exit()

To try this on riscv hardware or an online simulator, compile and run the following c program

const char main[]="\x05\x45\xef\x05\x20\x01Hello, World!\0\x35\x46\x93\x08\x00\x04\x73\0\0\0\x93\x08\xd0\x05\x73\0\0";

2

# FerNANDo, 109 bytes

7 7
3
5 5
6 5
4 3 3
0 5 3 0 7 3 0 0
0 5 7 0 0 5 0 4
0 6 5 2 4 6 2 3
0 6 6 0 7 7 2 3
0 6 6 2 5 4 7 4
2 2
3 5
3