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

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

## 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 ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

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

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

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

var OVERRIDE_REG = /^Override\s*header:\s*/i;

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

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      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],
        link: a.share_link,
      });
    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;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    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)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

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

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

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

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 188 137

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

@MartinBüttner Thanks, Mathcad answer added. – Stuart Bruff – 2016-03-25T13:24:51.023

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

Answers

484

Stuck, 0 bytes

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

Fatalize

Posted 2015-08-28T12:23:59.027

Reputation: 33 704

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!

galexite

Posted 2015-08-28T12:23:59.027

Reputation: 3 409

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:

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

primo

Posted 2015-08-28T12:23:59.027

Reputation: 31 689

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!

AlCode

Posted 2015-08-28T12:23:59.027

Reputation: 2 481

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, 6016 4234 4203 bytes

20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793

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

"9!dlroW ,olleH"ck,@

feersum

Posted 2015-08-28T12:23:59.027

Reputation: 30 146

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 Paddington
    Take District Line to Acton Town
    Take Piccadilly Line to Holloway Road
    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 Paddington
    Take Circle Line to Paddington
    Take District Line to Acton Town
    Take Piccadilly Line to Heathrow Terminals 1, 2, 3
    Take Piccadilly Line to Holborn
    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 District Line to Paddington
    Take Circle Line to Paddington
    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 Paddington
    Take Circle Line to Paddington
    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 District Line to Paddington
    Take Circle Line to Paddington
    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 Paddington
    Take Circle Line to Paddington
    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 Bakerloo Line to Paddington
    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
    ▀▀
    Holloway Road
      ▀▀▀
    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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.

    KSab

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 174

    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

    @Poke No, they don't beat Java

    – 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
    

    grc

    Posted 2015-08-28T12:23:59.027

    Reputation: 18 773

    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

    enter image description here

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

    enter image description here

    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.

    Edit: @primo's 84 codel solution.

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    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
           ^<<<<<<<
    

    Kade

    Posted 2015-08-28T12:23:59.027

    Reputation: 7 623

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

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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, 259 249 242 240 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*)+
       Ceiling[(n - 6)/2] 3(*additional initialiser*)+
       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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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.

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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.

    jrich

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 978

    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

    Piet Hello World

    28x3, here shown with codel width 10.

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

    Piet Layout

    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]
        6 add     cyn2 [6]
        7 dup     ylw2 [6, 6]
        8 mul     grn1 [36]
        9 dup     red1 [36, 36]
       10 dup     blu1 [36, 36, 36]
       11 add     mgn1 [36, 72]
    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]
       23 add     mgn0 [33, 100]
       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.

    primo

    Posted 2015-08-28T12:23:59.027

    Reputation: 31 689

    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, 192 150 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
     push 107 add printc
     jump p
    e:
     exit
    

    Remarks:

    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
    

    LukStorms

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 814

    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.

    Geobits

    Posted 2015-08-28T12:23:59.027

    Reputation: 19 281

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

    NinjaBearMonkey

    Posted 2015-08-28T12:23:59.027

    Reputation: 10 005

    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

    Related: https://codegolf.stackexchange.com/a/119682/65989

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

    grc

    Posted 2015-08-28T12:23:59.027

    Reputation: 18 773

    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

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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!

    LambdaBeta

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 629

    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*Pb8`qo42mZF.{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
    

    Jacob

    Posted 2015-08-28T12:23:59.027

    Reputation: 781

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

    kirbyfan64sos

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 922

    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!

    Beta Decay

    Posted 2015-08-28T12:23:59.027

    Reputation: 21 982

    What's a usuable? Is it like a usable? – CalculatorFeline – 2016-03-25T23:59:11.973

    36

    Unreadable, 843 755 732 666 645 629 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.

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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, 6293 6289 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

    alert`Hello, World!`
    

    takes even more bytes to encode (+1500 or so) because of the higher complexity of encoding two backticks rather than (" and ").

    me and my cat

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 127

    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, 4154 4135 4117 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!

    Kamila Szewczyk

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 510

    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]) <> ""
    

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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

    Luke Marlin

    Posted 2015-08-28T12:23:59.027

    Reputation: 401

    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.

    Olivier Grégoire

    Posted 2015-08-28T12:23:59.027

    Reputation: 12 225

    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!')
    

    Jo King

    Posted 2015-08-28T12:23:59.027

    Reputation: 43 006

    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!

    TheNumberOne

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 117

    28

    Pyth, 14 bytes

    "Hello, World!
    

    Doubt it'll get smaller than this in Pyth.

    orlp

    Posted 2015-08-28T12:23:59.027

    Reputation: 37 879

    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

    Beta Decay

    Posted 2015-08-28T12:23:59.027

    Reputation: 21 982

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

    Mitch Schwartz

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 039

    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 148 907 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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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!

    Blue

    Posted 2015-08-28T12:23:59.027

    Reputation: 27 508

    3Don't forget wrong caps :P – CalculatorFeline – 2017-06-20T21:24:27.823

    24

    Jelly, 8 bytes

    “3ḅaė;œ»
    

    Try it online!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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

    alert`Hello, 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.

    jrich

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 978

    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.

    user202729

    Posted 2015-08-28T12:23:59.027

    Reputation: 16 190

    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
    }
    

    ProgramFOX

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 167

    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.
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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.

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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 system

    The command block contains the code:

    tellraw @a "Hello, World!"

    This one doesn't really need an explanation.

    Addison Crump

    Posted 2015-08-28T12:23:59.027

    Reputation: 10 819

    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), 432 421 302 289 256 225 197 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.

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

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

    Fatalize

    Posted 2015-08-28T12:23:59.027

    Reputation: 33 704

    17

    Starry, 191 188 186 182 172 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!
    

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    17

    Piet, 93 codels

    The 1 pixel bitmap of the 31x3 program :

    Piet 31x3 - Codel 1[1]

    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 :

    Piet 31x3 - Codel 12[2]

    Remarks :

    Because of the upper-left black codel, npiet online seems to have a problem with it.
    But it works on PietDev.

    LukStorms

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 814

    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

    Downgoat

    Posted 2015-08-28T12:23:59.027

    Reputation: 27 735

    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.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 17 358

    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:

    Piet "Hello, World!" 13x15

    First version (15x15):

    Piet "Hello, World!"

    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>
    

    M L

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 015

    16

    Brain-Flak, 142 140 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.
    

    Wheat Wizard

    Posted 2015-08-28T12:23:59.027

    Reputation: 63 358

    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
    

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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   +  +  ++    ++  +   +
    +  +  ++      ++     +++
    + ++++ +    ++
    +      +  ++           ++
    +  +++++++   +++     ++  +
     ++    +    +   +  ++    + ++++
           +   +  +  ++      ++  +
           +  +  ++      ++  +  +
           + ++++ +    ++  +   +
           +      +  ++     +++
           +  +++++++
            ++    +   +++
        +         +  +   +  ++
        ++       +  +  +  ++  +
        + +     +  +  ++      + ++++
        +  +    + ++++ +      ++  +
         +  +   +      +  ++  +  +
          +  +  +  +++++++  +   +
        ++++  +  ++    +     +++
        +      +       +
         +      +++++++      +++
          +                ++   +
           +             ++     +
           +           ++      +
    ++++++++++++     ++   ++  ++++
     +     +    +  ++   ++  +     +
      ++++ +     ++   ++     +++++++
        +  +        ++
       +   +      ++
      +    +    ++
     +     +  ++
    +       ++        +++
    +               ++   +
    + +++++++     ++     +
    +  +     +  ++      +
    +   ++++  ++   ++  ++++
    +     +      ++  +     +
    +    +     ++     +++++++
    +    +   ++
    +  ++++++   +++++++     +++
     ++  +       +     +  ++   +
         +        ++++  ++     +
         +          +         +
         +      ++++     ++  ++++
         +             ++  +     +
         +  +++++++++++     +++++++
          ++
    

    Jerry Jeremiah

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 322

    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!
    

    jimmy23013

    Posted 2015-08-28T12:23:59.027

    Reputation: 34 857

    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.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    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 )
    

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    13

    BBC BASIC, 20 bytes

    PRINT"Hello, World!"
    

    Ahh, this was my first language :)

    Beta Decay

    Posted 2015-08-28T12:23:59.027

    Reputation: 21 982

    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.

    isaacg

    Posted 2015-08-28T12:23:59.027

    Reputation: 40 677

    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.

    ETHproductions

    Posted 2015-08-28T12:23:59.027

    Reputation: 48 410

    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 '!'.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    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.

    pmudra

    Posted 2015-08-28T12:23:59.027

    Reputation: 141

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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.

    Digital Trauma

    Posted 2015-08-28T12:23:59.027

    Reputation: 67 117

    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.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    11

    Lost, 57 54 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.

    Wheat Wizard

    Posted 2015-08-28T12:23:59.027

    Reputation: 63 358

    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.

    Downgoat

    Posted 2015-08-28T12:23:59.027

    Reputation: 27 735

    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.

    Random832

    Posted 2015-08-28T12:23:59.027

    Reputation: 816

    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:;@:
    

    Digital Trauma

    Posted 2015-08-28T12:23:59.027

    Reputation: 67 117

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

    ProgramFOX

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 167

    1

    +6 carrot.png

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

    29 byte gif

    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:

    30 byte path

    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.

    Jo King

    Posted 2015-08-28T12:23:59.027

    Reputation: 43 006

    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!

    Blue

    Posted 2015-08-28T12:23:59.027

    Reputation: 27 508

    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!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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, 46 45 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!<
    @
    

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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, 149 145 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
    }
    

    Kritzefitz

    Posted 2015-08-28T12:23:59.027

    Reputation: 200

    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.

    Alex A.

    Posted 2015-08-28T12:23:59.027

    Reputation: 23 922

    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:

    enter image description here
    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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.

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    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!
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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.

    MarkSill

    Posted 2015-08-28T12:23:59.027

    Reputation: 101

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

    plannapus

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 778

    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!

    kirbyfan64sos

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 922

    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.

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    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.

    Alex A.

    Posted 2015-08-28T12:23:59.027

    Reputation: 23 922

    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
    

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 37 000

    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
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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, 484 460 455 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)
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    8

    COBOL, 55 bytes

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

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

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    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.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 17 358

    8

    Brian & Chuck, 42 38 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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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"

    Fabrizio Calderan loves trees

    Posted 2015-08-28T12:23:59.027

    Reputation: 470

    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
            # implicitly added.
          ! # Regular exclamation mark
            # All the compressed words are automatically title cased.
              resulting in: "Hello, World!"
            
    

    This uses CP-1252 encoding

    Previous version:

    "Hello, World!
    

    Adnan

    Posted 2015-08-28T12:23:59.027

    Reputation: 42 659

    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.

    M L

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 015

    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:

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

    Or, in a readable fashion:

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

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

    oh heavens what have I made

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 37 000

    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  42 41 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
    

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

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

    jimmy23013

    Posted 2015-08-28T12:23:59.027

    Reputation: 34 857

    :| 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

    @ASCII-only Added the link to answer. Not sure it is actually better. – jimmy23013 – 2018-04-28T05:14:25.553

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

    Jo King

    Posted 2015-08-28T12:23:59.027

    Reputation: 43 006

    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!

    the default.

    Posted 2015-08-28T12:23:59.027

    Reputation: 7 585

    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,
    this becomes a repetitive task,
    this becomes a repetitive task,
    this becomes a repetitive task,
    this becomes a repetitive task,
    this becomes a repetitive task,
    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.
    Dear reader, please rest assured that we
    are ALMOST
    at the
    MIDDLE of
    this self referential program.
    Also, please refraing from adding the hyphen
    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,
    a really awesome gift
    from the mathematicians of yor to us.
    

    Builds on top of this awesome brainfuck answer.

    RGS

    Posted 2015-08-28T12:23:59.027

    Reputation: 12 552

    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

    rp.kelly

    Posted 2015-08-28T12:23:59.027

    Reputation: 91

    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

    jakebacker44

    Posted 2015-08-28T12:23:59.027

    Reputation: 71

    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:

    K`Hello, World!
    

    Try it online!

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    7

    Haskell, 26 bytes

    main=putStr"Hello, World!"
    

    Try it online!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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!

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    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!

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    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.

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    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.

    ETHproductions

    Posted 2015-08-28T12:23:59.027

    Reputation: 48 410

    7

    Bodyless HTTP response headers, 134 bytes

    HTTP/1.1 200 OK
    content-type: text/html
    link: <data:text/css,body:after{content:"Hello, World!"}>; rel=stylesheet
    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.

    Qwertiy

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 849

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

    mbomb007

    Posted 2015-08-28T12:23:59.027

    Reputation: 22 375

    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.

    primo

    Posted 2015-08-28T12:23:59.027

    Reputation: 31 689

    7

    MATL, 15 bytes

    'Hello, World!'
    

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

    Luis Mendo

    Posted 2015-08-28T12:23:59.027

    Reputation: 93 987

    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:

    enter image description here

    Zoomed in by a factor of 16:

    enter image description here

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

    SuperJedi224

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 480

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

    GamrCorps

    Posted 2015-08-28T12:23:59.027

    Reputation: 7 216

    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 {].

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 37 000

    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 '!'.
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

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

    ADDB

    Posted 2015-08-28T12:23:59.027

    Reputation: 171

    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, 124 123 111 99 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.

    MD XF

    Posted 2015-08-28T12:23:59.027

    Reputation: 12 356

    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
    • Add 1: 0x21
    • Times 10: 0x24
    • Times 16: 0x25
    • Output: 0x26
    • Character value: 0x28

    Zacharý

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 812

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

    Destructible Lemon

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 048

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

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 37 000

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

    ceilingcat

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 225

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

    RedClover

    Posted 2015-08-28T12:23:59.027

    Reputation: 729

    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 _
    

    Jo King

    Posted 2015-08-28T12:23:59.027

    Reputation: 43 006

    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.

    dingledooper

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 923

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

    Redwolf Programs

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 220

    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!

    the default.

    Posted 2015-08-28T12:23:59.027

    Reputation: 7 585

    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.

    AdmBorkBork

    Posted 2015-08-28T12:23:59.027

    Reputation: 42 210

    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.

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    6

    Pascal, 32 bytes

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

    aditsu quit because SE is EVIL

    Posted 2015-08-28T12:23:59.027

    Reputation: 22 528

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

    James

    Posted 2015-08-28T12:23:59.027

    Reputation: 55 525

    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                        
    

    MickyT

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 966

    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.

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    6

    Parenthetic, 766 698 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) .

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    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.

    Peter Taylor

    Posted 2015-08-28T12:23:59.027

    Reputation: 42 383

    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.

    Calvin's Hobbies

    Posted 2015-08-28T12:23:59.027

    Reputation: 86 100

    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... :(

    James

    Posted 2015-08-28T12:23:59.027

    Reputation: 55 525

    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.

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 37 000

    5

    Chip, 174 166 106 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.

    Phlarx

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 396

    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.

    • 0`0:"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

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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
    

    Laura Bostan

    Posted 2015-08-28T12:23:59.027

    Reputation: 191

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

    Leo

    Posted 2015-08-28T12:23:59.027

    Reputation: 10 034

    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.

    Matheus Avellar

    Posted 2015-08-28T12:23:59.027

    Reputation: 273

    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.

    Daniel O

    Posted 2015-08-28T12:23:59.027

    Reputation: 151

    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.

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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.

    Jo King

    Posted 2015-08-28T12:23:59.027

    Reputation: 43 006

    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:

    enter image description here

    Artur Kędzior

    Posted 2015-08-28T12:23:59.027

    Reputation: 151

    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!

    Readable:

    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!

    ASCII-only

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 949

    :| 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, 53 42 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
    

    Esolanging Fruit

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 090

    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

    MilkyWay90

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 464

    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

    enter image description here

    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.

    roblogic

    Posted 2015-08-28T12:23:59.027

    Reputation: 838

    5

    Cascade, 23 bytes

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

    Try it online!

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

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

    Jo King

    Posted 2015-08-28T12:23:59.027

    Reputation: 43 006

    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!

    user92069

    Posted 2015-08-28T12:23:59.027

    Reputation:

    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!

    See also: Showcase

    nph

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 270

    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!').
    

    Fatalize

    Posted 2015-08-28T12:23:59.027

    Reputation: 33 704

    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.

    Fatalize

    Posted 2015-08-28T12:23:59.027

    Reputation: 33 704

    5

    Forth, 17 bytes

    .( Hello, World!)
    

    mbomb007

    Posted 2015-08-28T12:23:59.027

    Reputation: 22 375

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

    AdmBorkBork

    Posted 2015-08-28T12:23:59.027

    Reputation: 42 210

    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.

    – AdmBorkBork – 2015-08-28T14:11:01.253

    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.

    – AdmBorkBork – 2015-08-28T15:40:58.330

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

    gilad hoch

    Posted 2015-08-28T12:23:59.027

    Reputation: 727

    5

    Bash, 18 bytes

    echo Hello, World!
    

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

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    5

    Applescript, 15 bytes

    "Hello, World!"
    

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

    Digital Trauma

    Posted 2015-08-28T12:23:59.027

    Reputation: 67 117

    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.

    Alex A.

    Posted 2015-08-28T12:23:59.027

    Reputation: 23 922

    5

    Unlambda, 36 bytes

    `.!`.d`.l`.r``.W`. `.,``.l`c`.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)))))
    

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    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.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    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.

    curiousdannii

    Posted 2015-08-28T12:23:59.027

    Reputation: 657

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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.
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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
    

    anatolyg

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 678

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

    primo

    Posted 2015-08-28T12:23:59.027

    Reputation: 31 689

    1Nice, I didn't know about the parameters it takes :) – Lynn – 2015-09-03T02:00:43.093

    5

    Jasmin, 251 219 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)

    ankh-morpork

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 435

    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.

    SuperJedi224

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 480

    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.

    dieter

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 998

    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.

    a spaghetto

    Posted 2015-08-28T12:23:59.027

    Reputation: 10 677

    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.

    Dale Johnson

    Posted 2015-08-28T12:23:59.027

    Reputation: 509

    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!

    Wheat Wizard

    Posted 2015-08-28T12:23:59.027

    Reputation: 63 358

    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 is included as tphelloworld.tp for the interpreter download.

    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
    

    Notes About the Interpreter

    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.

    ender_scythe

    Posted 2015-08-28T12:23:59.027

    Reputation: 249

    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

    Nice! I'm surprised anyone actually cares about this. – ender_scythe – 2016-11-18T17:51:02.013

    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!

    Pavel

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 679

    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
    

    Sok

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 862

    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

    Ada, 68 bytes (-15)

    Noticed there wasn't a plain Ada answer yet, only one with GNAT, so I made one:

    with Text_IO;procedure H is
    begin
    Text_IO.Put("Hello, World!");end;
    

    Thanks to 3D1T0R and breadbox for improving this!

    Try it online!

    python-b5

    Posted 2015-08-28T12:23:59.027

    Reputation: 109

    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.

    caird coinheringaahing

    Posted 2015-08-28T12:23:59.027

    Reputation: 24 300

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

    L3viathan

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 291

    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.

    Okx

    Posted 2015-08-28T12:23:59.027

    Reputation: 15 376

    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!

    Riley

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 465

    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.

    Bakna

    Posted 2015-08-28T12:23:59.027

    Reputation: 141

    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 ('!')
    

    No one

    Posted 2015-08-28T12:23:59.027

    Reputation: 71

    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
    • +: add
    • -: 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.

    Leaky Nun

    Posted 2015-08-28T12:23:59.027

    Reputation: 46 159

    4

    Plain English 901 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.

    Jasper

    Posted 2015-08-28T12:23:59.027

    Reputation: 439

    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
    

    Jerry Jeremiah

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 322

    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.

    totallyhuman

    Posted 2015-08-28T12:23:59.027

    Reputation: 15 657

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

    Jerry Jeremiah

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 322

    4

    Numberwang, 77 bytes

    69696969696969693696969623673363316969696968359533059595636969663633563583193
    

    Try it online!

    Just incrementing and decrementing the pointer by certain amounts.

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 37 000

    Brainfuck translation, 72 – ASCII-only – 2018-04-14T07:36:40.937

    4

    ADJUST, 281 bytes

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

    Diagonal }; turn IP right. I-, e$, m-, etc. create ascii code in the accumulator and push it on both stacks. A print char. gR};& move IP to the first line. = swap stacks. C exit.

    stasoid

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 375

    4

    ELVM-IR, 116 68 66 65 bytes

    .data
    .string"Hello, World!"load B,A
    putc B
    add A,1jne 0,A,13exit
    

    Thanks to @ASCII-only for golfing off 48 50 51 bytes!

    Try it online!

    Background

    Running the above program with eli <file> interprets it, but elc -<target> <file> is where the real magic happens: it translates ELVM-IR source code to any of the supported backends!

    Try it online!

    The ELVM toolchain also supports compiling (a subset of) C and its standard library to ELVM-IR.

    Try it online!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    78 bytes – ASCII-only – 2018-04-11T04:41:31.840

    68 bytes – ASCII-only – 2018-04-11T04:56:40.433

    40% shorter now. Thank you! – Dennis – 2018-04-11T05:18:19.527

    golfed another two bytes off :P – ASCII-only – 2018-04-13T04:57:43.023

    Looks weird, but it works. Thanks! – Dennis – 2018-04-13T05:20:15.360

    65. looks even weirder >_> – ASCII-only – 2018-05-15T22:38:47.437

    @ASCII-only Thanks again! – Dennis – 2018-05-17T04:13:36.157

    4

    095, 16 bytes

    'Hello, World!'s
    

    First answer in my attempt at making a programming language! Pushes Hello, World! to the stack and then prints.

    user77814

    Posted 2015-08-28T12:23:59.027

    Reputation:

    2Welcome to PPCG! – Erik the Outgolfer – 2018-01-25T20:43:56.210

    4

    Atari Logo, 21 bytes

    Code:

    PRINT [HELLO, WORLD!]
    

    Result:

    enter image description here

    Grant Miller

    Posted 2015-08-28T12:23:59.027

    Reputation: 774

    4

    ]=[, 164 bytes

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

    ]=[ was a language which only uses the symbols ], =, and [.

    The ]=[ interpreter is written in 12-Basic.

    12Me21

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 290

    There's something amusing about the fact that the ]=[ interpreter at the link is written in the 12-basic interpreter. – snail_ – 2018-05-31T20:18:24.680

    Permalink no longer works – ASCII-only – 2018-12-26T01:07:34.237

    now I can't find the interpreter... – 12Me21 – 2018-12-28T03:18:18.090

    I was looking through some old files and I found the interpreter, finally. – 12Me21 – 2019-03-13T21:32:26.710

    4

    Nikud, 672 bytes

    ֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֲֳֳֳֳֳֳֳֳֳֳֳֳֳֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָ
    

    Try it online

    Even though it has tons of bytes, it's top 3 in width, as all the characters are diacritical marks.

    There isn't much useful to explain. The character codes are put in reverse order into the stack using mostly אֱ (push 1), אֶ (dup) and אַ (add). Then אֵ (print as char) is called 13 times.

    Another thing that adds to the byte count is that each character is represented by 2 bytes in UTF-8. So it's actually 336 characters.

    Bary12

    Posted 2015-08-28T12:23:59.027

    Reputation: 189

    I think this can be golfed more using multiplication. – Windmill Cookies – 2018-06-14T05:17:04.000

    4

    Bootable x86 machine code, 512 bytes

    Hexdump:

    31 c9 8e d9 be 10 7c b1  0d ac b4 0e cd 10 e2 f9  |1.....|.........|
    48 65 6c 6c 6f 2c 20 57  6f 72 6c 64 21 00 00 00  |Hello, World!...|
    *
    00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
    

    * represents 464 bytes of padding required to place the bootable flag (55 aa) at offset 510.

    This is the same as the following assembler code, which can be assembled using nasm hello.asm -f bin -o hello.bin, assuming the assembler code is in a file called hello.asm

    [ORG 0x7C00]
    [BITS 16]
    
        xor cx, cx      ; Set cx to 0
        mov ds, cx      ; Set ds to cx (0)
        mov si, msg     ; Set si to the address of the message
        mov cl, 13      ; Set cx to 13 (the size of the message)
    print_loop:         ; For each character in the message:
        lodsb           ;   Set al to the character
        mov ah, 0x0E    ;   Set ah to 0x0E
        int 0x10        ;   Call interrupt 0x10 (video services) with ah set to 0x0E (print al to screen)
        loop print_loop ;   Decrement cx and continue the loop if cx > 0
    
    msg:
        db 'Hello, World!' 
    
    times 510 - ($-$$) db 0
    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
    

    Herman L

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 841

    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.

    Lyxal

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 711

    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.

    MilkyWay90

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 464

    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.

    ais523

    Posted 2015-08-28T12:23:59.027

    Reputation: 11

    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.

    programical

    Posted 2015-08-28T12:23:59.027

    Reputation: 41

    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!

    EdgyNerd

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 236

    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.

    user85052

    Posted 2015-08-28T12:23:59.027

    Reputation:

    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.

    caird coinheringaahing

    Posted 2015-08-28T12:23:59.027

    Reputation: 24 300

    4

    International Phonetic Esoteric Language, 16 bytes

    "Hello, World!"o
    
    "Hello, World!"  (push "Hello, World!")
                   o (pop and print)
    

    bigyihsuan

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 161

    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!

    JosiahRyanW

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 290

    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.

    Lyxal

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 711

    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.

    sporeball

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 528

    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

    noise

    Posted 2015-08-28T12:23:59.027

    Reputation: 321

    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
    4OUR$$$$fuor$$$$fuor$$$$4OUR$$$$4OUR      {44} CELL[1] + 4 * 4 * 4 + 4 + 4
    4444                                      {44} Print CELL[1]
    FO44                                      {44} Next Cell
    
    {44} e -> 101
    4OUR$$$$4OUR$$$$4OUR$$$$4OUR$$$$4OUR      {44} CELL[2] + 4 + 4 + 4 + 4 + 4
    fuor$$$$4OUR$$$$4OUR$$$$4OUR$$$$4OUR      {44} CELL[2] * 4 + 4 + 4 + 4 + 4
    4OUR$$$$fuor$$$$4OUR$$$$four              {44} CELL[2] + 4 * 4 + 4 / 4
    4444                                      {44} Print CELL[2]
    
    {44} l -> 108
    fuor$$$$4OUR$$$$4OUR$$$$4OUR$$$$4OUR      {44} CELL[2] * 4 + 4 + 4 + 4 + 4
    4OUR$$$$4OUR$$$$4OUR$$$$four              {44} CELL[2] + 4 + 4 + 4 / 4
    4444$$$$4444                              {44} Print CELL[2] twice
    
    {44} o -> 111
    fuor$$$$4OUR$$$$4OUR$$$$4OUR$$$$four      {44} CELL[2] * 4 + 4 + 4 + 4 / 4
    4444                                      {44} Print CELL[2]
    FO44                                      {44} Next Cell
    
    {44} , -> 44
    4OUR$$$$4OUR$$$$4OUR$$$$fuor$$$$FOU4      {44} CELL[3] + 4 + 4 + 4 * 4 - 4
    4444                                      {44} Print CELL[3]
    
    {44} Whitespace -> 32
    ffff                                      {44} Reset CELL[3]
    4OUR$$$$4OUR$$$$fuor                      {44} CELL[3] + 4 + 4 * 4
    4444                                      {44} Print CELL[3]
    FO44                                      {44} Next Cell
    
    {44} W -> 87
    4OUR$$$$4OUR$$$$4OUR$$$$4OUR$$$$4OUR      {44} CELL[4] + 4 + 4 + 4 + 4 + 4
    fuor$$$$4OUR$$$$4OUR$$$$fuor$$$$FOU4      {44} CELL[4] * 4 + 4 + 4 * 4 - 4
    four                                      {44} CELL[4] / 4
    4444                                      {44} Print CELL[4]
    
    {44} o -> 111
    4OUR$$$$4OUR$$$$4OUR$$$$4OUR$$$$4OUR      {44} CELL[4] + 4 + 4 + 4 + 4 + 4
    4OUR                                      {44} CELL[4] + 4
    4444                                      {44} Print CELL[4]
    
    {44} r -> 114
    4OUR$$$$fuor$$$$FOU4$$$$four              {44} CELL[4] + 4 * 4 - 4 / 4
    4444                                      {44} Print CELL[4]
    
    {44} l -> 108
    FOU4$$$$FOU4$$$$fuor$$$$4OUR$$$$4OUR      {44} CELL[4] - 4 - 4 * 4 + 4 + 4
    four                                      {44} CELL[4] / 4
    4444                                      {44} Print CELL[4]
    
    {44} d -> 100
    FOU4$$$$FOU4                              {44} CELL[4] - 4 - 4
    4444                                      {44} Print CELL[4]
    44UR                                      {44} Prev Cell
    
    {44} ! -> 33
    fuor$$$$4OUR$$$$four                      {44} CELL[3] * 4 + 4 / 4
    4444                                      {44} Print CELL[3]
    

    Try it online!

    noise

    Posted 2015-08-28T12:23:59.027

    Reputation: 321

    4

    Mornington Crescent, 3328 3271 bytes

    Take Northern Line to Leicester Square
    Take Piccadilly Line to Heathrow Terminals 1, 2, 3
    Take Piccadilly Line to Holborn
    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 Paddington
    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 Holloway Road
    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 District Line to Paddington
    Take Circle Line to Paddington
    Take Hammersmith & City Line to Barking
    Take Hammersmith & City Line to Paddington
    Take Circle 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 District Line to Paddington
    Take Circle Line to Paddington
    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 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 Circle Line to Paddington
    Take Bakerloo Line to Charing Cross
    Take Bakerloo Line to Paddington
    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)
    --                     --
    
    Holloway Road
      ---
    
    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 Piccadilly Line to Holborn
    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
    Take District Line to Bow Road // Bow Road = 1
    
    // 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
    Take District Line to Paddington // Paddington = "He"
    
    // 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"
    
    // Get "Holloway Road"
    Take District Line to Acton Town
    Take Piccadilly Line to Holloway Road
    
    // 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"
    Take District Line to Paddington
    Take Circle Line to Paddington
    
    // 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
    
    // Add 1
    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, "
    Take District Line to Paddington
    Take Circle Line to Paddington
    
    // ### 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
    Take Circle 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
    Take Circle Line to Paddington
    
    // get "!" and append it to "Hello, World"
    Take Bakerloo Line to Charing Cross
    Take Bakerloo Line to Paddington
    
    // go home
    Take Circle Line to Bank
    Take Circle Line to Bank
    Take Northern Line to Mornington Crescent
    

    Dorian

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 437

    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.\
    Your brain gets smart, bu
    t y
    our head g
    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

    Assembly-like representation

    push 8
    dup
    push 1
    add
    mul
    dup
    outa
    push 29
    add
    dup
    outa
    push 7
    add
    dup
    dup
    outa
    outa
    push 3
    add
    outa
    push 11
    push 4
    mul
    dup
    dup
    outa
    push 12
    sub
    outa
    dup
    add
    push 1
    sub
    dup
    outa
    push 24
    add
    dup
    outa
    push 3
    add
    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
    add
    ----------
    [8,9]
    7
    mul
    ----------
    [72]
    8
    dup
    ----------
    [72,72]
    9
    outa:::::::::
    H----------
    [72]
    10
    push
    ----------
    [72,29]
    12
    add
    ----------
    [101]
    13
    dup
    ----------
    [101,101]
    14
    outa:::::::::
    e----------
    [101]
    15
    push
    ----------
    [101,7]
    17
    add
    ----------
    [108]
    18
    dup
    ----------
    [108,108]
    19
    dup
    ----------
    [108,108,108]
    20
    outa:::::::::
    l----------
    [108,108]
    21
    outa:::::::::
    l----------
    [108]
    22
    push
    ----------
    [108,3]
    24
    add
    ----------
    [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
    add
    ----------
    [88]
    40
    push
    ----------
    [88,1]
    42
    sub
    ----------
    [87]
    43
    dup
    ----------
    [87,87]
    44
    outa:::::::::
    W----------
    [87]
    45
    push
    ----------
    [87,24]
    47
    add
    ----------
    [111]
    48
    dup
    ----------
    [111,111]
    49
    outa:::::::::
    o----------
    [111]
    50
    push
    ----------
    [111,3]
    52
    add
    ----------
    [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:::::::::
    !----------
    []
    

    Lyxal

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 711

    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.

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

    mbomb007

    Posted 2015-08-28T12:23:59.027

    Reputation: 22 375

    4

    unc, 38 bytes

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

    kirbyfan64sos

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 922

    4

    LOLCODE, 22 bytes

    VISIBLE"Hello, World!"
    

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

    Fatalize

    Posted 2015-08-28T12:23:59.027

    Reputation: 33 704

    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

    mbomb007

    Posted 2015-08-28T12:23:59.027

    Reputation: 22 375

    4

    Nim, 20 19 bytes

    echo"Hello, World!"
    

    Saved one byte thanks to sp3000!

    kvill

    Posted 2015-08-28T12:23:59.027

    Reputation: 329

    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.

    kirbyfan64sos

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 922

    4

    TI-BASIC, 22 bytes

    "Hello, World!
    

    Note that the lowercase letters are 2 bytes each.

    TheNumberOne

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 117

    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.

    AdmBorkBork

    Posted 2015-08-28T12:23:59.027

    Reputation: 42 210

    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.
    

    Rohcana

    Posted 2015-08-28T12:23:59.027

    Reputation: 210

    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.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

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

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    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.

    isaacg

    Posted 2015-08-28T12:23:59.027

    Reputation: 40 677

    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

    Beta Decay

    Posted 2015-08-28T12:23:59.027

    Reputation: 21 982

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

    alephalpha

    Posted 2015-08-28T12:23:59.027

    Reputation: 24 427

    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!
    

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    @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'.

    Beta Decay

    Posted 2015-08-28T12:23:59.027

    Reputation: 21 982

    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:

    Piet code

    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.

    Made and tested on PietDev.

    plannapus

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 778

    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.

    For more info, visit the Esolangs wiki page. Suggestions welcome!

    ETHproductions

    Posted 2015-08-28T12:23:59.027

    Reputation: 48 410

    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

    @Tealpelican See also MickyT's 120 byte answer

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

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    4

    Gol><>, 16 bytes

    "!dlroW ,olleH"H
    

    Try it online.

    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.

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    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.

    Addison Crump

    Posted 2015-08-28T12:23:59.027

    Reputation: 10 819

    4

    Japt, 15 14 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)

    ETHproductions

    Posted 2015-08-28T12:23:59.027

    Reputation: 48 410

    4

    TeaScript, 12 bytes

    (using ISO/IEC 8859 character encoding)

    D`HÁM, Wld!
    

    Compresses Hello, World!, decompresses with D (æ) function

    Downgoat

    Posted 2015-08-28T12:23:59.027

    Reputation: 27 735

    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.

    quintopia

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 869

    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)

    Adnan

    Posted 2015-08-28T12:23:59.027

    Reputation: 42 659

    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

    Script
    (scoring used)
    Makes the sprite say "Hello, World!" Can't get much simpler than that.

    weatherman115

    Posted 2015-08-28T12:23:59.027

    Reputation: 645

    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
    

    user48538

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 482

    4

    Your Mom, 14 bytes

    'Hello, World!
    

    Explanation

    '...
    '... - Push the string. The ending ' is not needed at the end of program
         - Implicit output
    

    user48538

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 482

    4

    Emojicode, 37 bytes

    Hello, World!
    

    betseg

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 585

    4

    Golfuck, 39 bytes

    jrseeqzjzzzsvDsj*aaa*r"s*hB(FsxahB(z*sh
    

    Credit to primo, this is his answer, but in Golfuck.

    acrolith

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 788

    4

    Addict, 248 bytes

    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!

    Primer on addict

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

    See the GitHub repo for more information about Addict.


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

    Through the same process, C adds 8, D adds 16, and E adds 32.

    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!

    ETHproductions

    Posted 2015-08-28T12:23:59.027

    Reputation: 48 410

    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.

    FlipTack

    Posted 2015-08-28T12:23:59.027

    Reputation: 13 480

    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.

    M L

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 015

    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
    

    Chance

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 308

    3

    Threead, 16 bytes

    "Hello, World!"o
    

    Try it online!

    Pavel

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 679

    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.

    Business Cat

    Posted 2015-08-28T12:23:59.027

    Reputation: 9 127

    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.

    Josh

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 051

    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

    caird coinheringaahing

    Posted 2015-08-28T12:23:59.027

    Reputation: 24 300

    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 :)

    No one

    Posted 2015-08-28T12:23:59.027

    Reputation: 71

    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.');
            }
        }
    }

    Nissa

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 476

    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.

    James

    Posted 2015-08-28T12:23:59.027

    Reputation: 55 525

    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!
    

    Eran W

    Posted 2015-08-28T12:23:59.027

    Reputation: 131

    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.
    

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    3

    Forked, 42 bytes

    89*@AA*i@7+@@3+@4B*@C'!sF+!@3+@6'@8'!3B*!&
    

    Try it online!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    3

    AlphaBeta, 68 bytes

    kjjjggDLeaCLcbbbCLLaaaCLjjjggDLjhhDLsFihhDLCLaaaCLdaaaaCLdaaCLsFiiDL
    

    Try it online!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    3

    Dodos, 167 164 160 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!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    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
    

    ASCII-only

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 949

    3

    Rockstar, 21 bytes

    Shout "Hello, World!"
    

    Yeah, kinda boring... oh well.

    Skidsdev

    Posted 2015-08-28T12:23:59.027

    Reputation: 10 009

    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
    

    Taylor Scott

    Posted 2015-08-28T12:23:59.027

    Reputation: 7 199

    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.

    Beta Decay

    Posted 2015-08-28T12:23:59.027

    Reputation: 21 982

    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.

    SIGSTACKFAULT

    Posted 2015-08-28T12:23:59.027

    Reputation: 605

    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.

    Nissa

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 476

    3

    Kitten, 18 bytes

    "Hello, World!"say
    

    alephalpha

    Posted 2015-08-28T12:23:59.027

    Reputation: 24 427

    3

    Alchemist, 24 22 bytes

    _->Out_"Hello, World!"
    

    Try it online!

    ბიმო

    Posted 2015-08-28T12:23:59.027

    Reputation: 15 893

    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
    

    u-ndefined

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 413

    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.

    Esolanging Fruit

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 090

    3

    Bitwise Cyclic Tag But Way Worse, 324 bytes

    1111111111111111111111111111111111111111111111111111111110110101101010101110101101101110111010101110111010101110111110101101110101010110101010101011011011110111011111011110101101011101110101011101011010101011010101011n0200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
    

    Try it online!

    MilkyWay90

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 464

    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
    

    NieDzejkob

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 940

    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

    Let us continue this discussion in chat.

    – 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!";
    

    ceilingcat

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 225

    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!

    u-ndefined

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 413

    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
    

    user85052

    Posted 2015-08-28T12:23:59.027

    Reputation:

    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.

    Jo King

    Posted 2015-08-28T12:23:59.027

    Reputation: 43 006

    Nice! I'm doing nothing now. – null – 2019-10-09T09:56:02.137

    3

    W d, 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.

    user85052

    Posted 2015-08-28T12:23:59.027

    Reputation:

    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!

    Herman L

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 841

    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.

    Slord6

    Posted 2015-08-28T12:23:59.027

    Reputation: 101

    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.

    Jo King

    Posted 2015-08-28T12:23:59.027

    Reputation: 43 006

    3

    Roj, 18 bytes

    I love this simple BASIC dialect ...

    out"Hello, World!"
    

    Explanation

    out                $ Output $
       "Hello, World!" $ the string "Hello, World" $
    

    user92069

    Posted 2015-08-28T12:23:59.027

    Reputation:

    3

    MAWP, 86 62 bytes

    89W!;74WM1M!;7M!!;;3M;66W8M;84W;99W6M!;64WM!;3M!;6A!;8A;66W3A;
    

    Try it!

    Dion

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 372

    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

    ZippyMagician

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 111

    3

    CSS, 62 bytes:

    *{display:none}html{display:flex}:after{content:'Hello World!'
    

    This is the first pure CSS on here, I think.

    derder56

    Posted 2015-08-28T12:23:59.027

    Reputation: 75

    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@../.
    

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 17 358

    3

    Kotlin, 33 bytes

    fun main()=print("Hello, World!")
    

    This is probably the shortest you can go.

    grian

    Posted 2015-08-28T12:23:59.027

    Reputation: 81

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

    mbomb007

    Posted 2015-08-28T12:23:59.027

    Reputation: 22 375

    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.
    

    mbomb007

    Posted 2015-08-28T12:23:59.027

    Reputation: 22 375

    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
    

    Perl/Tk Hello, World!

    LukStorms

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 814

    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
    

    Kade

    Posted 2015-08-28T12:23:59.027

    Reputation: 7 623

    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
    

    Kade

    Posted 2015-08-28T12:23:59.027

    Reputation: 7 623

    3

    golflua, 16 bytes

    w"Hello, World!"
    

    manatwork

    Posted 2015-08-28T12:23:59.027

    Reputation: 18 847

    3

    VBA, 15

    ?"Hello, World!
    

    Try it, for instance, in the "Immediate" panel of the development window in MS Excel.

    edc65

    Posted 2015-08-28T12:23:59.027

    Reputation: 31 416

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

    kvill

    Posted 2015-08-28T12:23:59.027

    Reputation: 329

    3

    CJam, 15 bytes

    "Hello, World!"
    

    Try it online

    aditsu quit because SE is EVIL

    Posted 2015-08-28T12:23:59.027

    Reputation: 22 528

    3

    XSM, 28 bytes

    <print>Hello, World!</print>
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

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

    aditsu quit because SE is EVIL

    Posted 2015-08-28T12:23:59.027

    Reputation: 22 528

    3

    ///, 13

    Hello, World!
    

    can't get much simpler than this

    proud haskeller

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 946

    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.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

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

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    3

    bc, 16 bytes

    "Hello, World!"
    

    (bc requires a trailing newline - hence 16 instead of 15)

    Digital Trauma

    Posted 2015-08-28T12:23:59.027

    Reputation: 67 117

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

    aditsu quit because SE is EVIL

    Posted 2015-08-28T12:23:59.027

    Reputation: 22 528

    3

    Idris, 36 bytes

    main:IO();main=putStr"Hello, World!"
    

    Idris is sort of like Haskell, but top-level definitions need a type signature.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    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.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    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.

    undergroundmonorail

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 937

    3

    Fueue, 47 bytes

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

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

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

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 188 137

    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!").

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 17 358

    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.

    Sp3000

    Posted 2015-08-28T12:23:59.027

    Reputation: 59 387

    3

    Aheui, 177 bytes

    밣밢따빠빠빠맣밤밢따다빠빠빠밠타맣맣맣받다맣밠밤따타맣밤밣따맣받발따다빠맣밦밤따다빠빠맣받다맣받타빠맣밣타빠맣받나맣희
    

    Aheui is Befunge, but with Hangul. Test this here.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 58 974

    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.

    user15259

    Posted 2015-08-28T12:23:59.027

    Reputation:

    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.

    Kametrixom

    Posted 2015-08-28T12:23:59.027

    Reputation: 426

    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>

    MickyT

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 966

    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.

    Mark

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 167

    3

    Simplex, 16 bytes

    "Hello, World!"g
    

    g is the standard output mechanism.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 17 358

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

    DLosc

    Posted 2015-08-28T12:23:59.027

    Reputation: 23 122

    @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, 216 211 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.

    Bassdrop Cumberwubwubwub

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 729

    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!

    Cyoce

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 888

    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.

    a spaghetto

    Posted 2015-08-28T12:23:59.027

    Reputation: 10 677

    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!");
    

    Jerry Jeremiah

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 322

    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.

    Rɪᴋᴇʀ

    Posted 2015-08-28T12:23:59.027

    Reputation: 7 376

    3

    Verilog, 60 bytes

    module m;initial
    begin
    $write("Hello, World!");end
    endmodule
    

    Try it online here.

    Justin

    Posted 2015-08-28T12:23:59.027

    Reputation: 20 247

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

    Justin

    Posted 2015-08-28T12:23:59.027

    Reputation: 20 247

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

    Jerry Jeremiah

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 322

    3

    Kotlin, 50 48 bytes

    fun main(a:Array<String>)=print("Hello, World!")
    

    Rames

    Posted 2015-08-28T12:23:59.027

    Reputation: 221

    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
    

    TuxCrafting

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 699

    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.

    clismique

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 742

    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";
    

    Note that Windows Services for Linux currently doesn't seem to support this type of syscall.

    ceilingcat

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 225

    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.

    Cody

    Posted 2015-08-28T12:23:59.027

    Reputation: 453

    3

    Codelike, 127 bytes

    on++++++++n+++n+++**pn++++n+++++++*+ap+++++++pp+++pn++++n++++++++*pfn++n++++*ap________p+++p______p________pn++++n++++++++*+pfe
    

    Try it!

    Connor D

    Posted 2015-08-28T12:23:59.027

    Reputation: 91

    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.

    Harry

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 251

    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!

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 37 000

    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"
    

    anna328p

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 949

    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.
    

    James Holderness

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 598

    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
    

    MercyBeaucou

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 967

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

    snail_

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 370

    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!

    Erik the Outgolfer

    Posted 2015-08-28T12:23:59.027

    Reputation: 39 182

    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‹
    

    user63571

    Posted 2015-08-28T12:23:59.027

    Reputation:

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

    Shaun Bebbers

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 864

    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.

    TuxCrafting

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 699

    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.

    caseif

    Posted 2015-08-28T12:23:59.027

    Reputation: 121

    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

    Add 1 to the accumulator

    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)

    caird coinheringaahing

    Posted 2015-08-28T12:23:59.027

    Reputation: 24 300

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

    Daniel F

    Posted 2015-08-28T12:23:59.027

    Reputation: 21

    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.

    ASCII-only

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 949

    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
    

    Skidsdev

    Posted 2015-08-28T12:23:59.027

    Reputation: 10 009

    >

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

    Zacharý

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 812

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

    arodebaugh

    Posted 2015-08-28T12:23:59.027

    Reputation: 597

    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.

    ATaco

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 250

    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
    

    Alex

    Posted 2015-08-28T12:23:59.027

    Reputation: 427

    2

    Fishing, 25 24 bytes

    [+_
    |C]`Hello, World!`Ni
    

    It exits with an error.

    Fishing, 34 bytes

    v+CCCCCCCC^]
      `Hello, 
      N`!dlroW
    

    Without errors.

    jimmy23013

    Posted 2015-08-28T12:23:59.027

    Reputation: 34 857

    2

    Neim, 16 bytes

    (Hello, World!)B
    

    Try here

    Made possible thanks to (partial) BigInteger support.

    Erik the Outgolfer

    Posted 2015-08-28T12:23:59.027

    Reputation: 39 182

    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.

    Skidsdev

    Posted 2015-08-28T12:23:59.027

    Reputation: 10 009

    2

    Emoji, 23 24 bytes

    Hello, World!➡ 
    

    Should be pretty clear. Just pushes Hello, World! and than outputs.

    ABot

    Posted 2015-08-28T12:23:59.027

    Reputation: 213

    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.

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 37 000

    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!

    MD XF

    Posted 2015-08-28T12:23:59.027

    Reputation: 12 356

    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.

    Zacharý

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 812

    2

    AsciiDots, 18 bytes

    .-$"Hello, World!"
    

    Try it online!

    user31415

    Posted 2015-08-28T12:23:59.027

    Reputation: 151

    2

    DOBELA, 214 bytes

    ,,.,,,,.,..,,.,,,..,..,,,...,,.,,..,....,.,.,...,,.,,,,,,,.,..,,,..,....,..,..,,,..,..,,,..,,.,.,.,,.,,,$^
    .                                                                                                         #
    

    With comments:

    !        d        l        r        o        W                 ,        o        l        l        e        H
    ,,.,,,,. ,..,,.,, ,..,..,, ,...,,., ,..,.... ,.,.,... ,,.,,,,, ,,.,..,, ,..,.... ,..,..,, ,..,..,, ,..,,.,. ,.,,.,,,$^
    .                                                                                                                     #
    
    H = ascii 0x48 = 01001000 = ,.,,.,,,
    

    Put bits in FIFO then print them by hitting ^ from below.

    Try it online

    stasoid

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 375

    123 – ASCII-only – 2018-04-12T04:20:27.150

    2

    LNUSP, 360 353 bytes

    -6 bytes thanks to ASCII-only

    001 . !.!
    002 !    !
    001 *  !!
    033 +
    001 *
    100 +
    001 *
    108 +
    001 *
    114 +
    001 *
    111 +
    001 *
    087 +
    001 *
    032 +
    001 *
    044 +
    001 *
    111 +
    001 *
    108 +
    001 *
    108 +
    001 *
    101 +
    001 *
    057 +
    015 +                    ?...?@             !
    001 *                   ?@ .  ?
    001 !                   . +.  *
    001  .                  ?  !  ?
    001   !..................?.@.?
    

    Ungolfed version:

    001 . !.!                  .OUTPUT          .EXIT
    001  .   !                 .                .
    001 ! .  !                 .                .
    001 .  !!                  .                .
    001 *                      .                .
    033 + !                    .                .
    001 *                      .                .  
    100 + d                    .                .
    001 *                      .                .
    108 + l                    .                .
    001 *                      .                .
    114 + r                    .                .
    001 *                      .                .
    111 + o                    .                .
    001 *                      .                .
    087 + W                    .                .
    001 *                      .                .
    032 +                      .                .
    001 *                      .                .
    044 + ,                    .                .
    001 *                      .                .
    111 + o                    .                .
    001 *                      .                .
    108 + l                    .                .
    001 *                      .                .
    108 + l                    .                .
    001 *                      .                .
    101 + e                    .                .
    001 *                      .                .
    072 + H                    .                .
    001 *                      .                !
    001 .                      .               .
    001 .                      .              .
    001 .                      .             .
    001 .                      .            .
    001 !                      .           .
    001  .                     .          .
    001   .                    .         .
    001    .                   .        .
    001     .                @ .       .
    001      .                +.      .
    001       .                !     .
    001        .               .    .
    001         .           ?.....?@
    001          .         ?   .   ?
    001           .        .   .   *
    001            .       ?   .   ?
    001             !.......?..@..?
    

    Note that TIO LNUSP does not require newline at the end of file.
    Some explanations are here. Can be golfed 4 bytes more, I didn't do it for aesthetic purpose.

    Try it online

    stasoid

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 375

    You can move the topmost * one line up – ASCII-only – 2018-04-14T02:26:35.483

    Also, what is the 4-byte golf? I'm assuming it's removing one character from the right side of the print loop? – ASCII-only – 2018-04-14T02:42:53.193

    re: topmost *: never mind. it appears you can remove it completely – ASCII-only – 2018-04-14T02:49:49.623

    @ASCII-only yes (about 4-byte golf) – stasoid – 2018-04-14T04:28:06.813

    2

    LLVM IR, 110 bytes

    @s=global[13x i8]c"Hello, World!"declare i8@puts([13x i8]*)define i8@main(){call i8@puts([13x i8]*@s)ret i8 0}
    

    Try it online!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 200 652

    2

    Triangularity, 71 49 bytes

    .... ....
    ..."!"...
    .."ld"+..
    ." Wor"+.
    "Hello,"+
    

    Try it online!

    Saved 22 bytes thanks to an ingenious method by Mr. Xcoder!

    Old version

    ...........
    ...."H"....
    ..."ell"...
    .."o, Wo"..
    ."rld!"W"".
    .....J.....
    

    Try it online!

    caird coinheringaahing

    Posted 2015-08-28T12:23:59.027

    Reputation: 24 300

    2

    Stax, 8 bytes

    èï┬▀↨╩4G
    

    Run and debug online!

    Explanation

    èï┬▀↨╩4G is the packed form of the ASCII Stax code `jaH1"jS3!, which is in turn a compressed string literal of Hello, World! with the ending backtick omitted.

    Weijun Zhou

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 486

    2

    Min, 20 bytes

    "Hello, World!" puts
    

    Panda0nEarth

    Posted 2015-08-28T12:23:59.027

    Reputation: 111

    2

    ALPHA, 36 bytes

    ALPHA is a palindomic alphabetical esoteric programming language made by me and caird. Thought it would be fun to write an answer here.

    ALPHA is made of mirrored alphabetical "Containers" that perform programming commands.

    KMDHello World!DMK
    

    Explanation:

    K - Start line container
    M - Start print container
    D - Start string container
    Hello World!
    D - End string container
    M - End print container
    K - End line container
    

    This lang is WIP. If you want to fix bugs, fork the interpreter, or contribute to completing the interpreter, Go to ALPHA's repository.

    Mercury Platinum

    Posted 2015-08-28T12:23:59.027

    Reputation: 161

    2

    PHP (on a standard Apache Server, result needing to target STDOUT), 30 27 Bytes

    <?php die("Hello, World!");
    

    Note: this is not to detract form earlier PHP example relied on an option assuming PHP wasn't being used as a webserver and abusing the HTML-effect outside of ?php tags to have an answer that was just "Hello, World!"

    That said, that solution made some non-standard server assumptions which aren't common with PHP. So I'm presenting an alternative that assumes a normal server layout, but still needs to go to STDOUT. This is not to detract from the previous posters example, but to present one in a different setting with different constraints.

    Note: originally thought using

    <?php fwrite(STDOUT,"Hello, World!"); ?> 
    

    would be the only way, but then realized the die (normally used killing the script with an error) outputted to STDOUT and didn't use extra variables.

    Updated: Cut off a few bytes recalling that "die" wont' bother with anything after itself, so didn't need the closing ?>.

    Note: Worth noting, that if shorttags were on with a PHP5 server, could drop down 3 more bytes to 24 bytes with

    <? die("Hello World!"); 
    

    However, I was specifically going a standard server, and shortags are now off by default making a server with them on no longer standard.

    Example (courtesy of Scrooble): Try It Online!

    lilHar

    Posted 2015-08-28T12:23:59.027

    Reputation: 131

    1

    Welcome to the site, and nice answer and explanation! It is common practice here to include a Try it online! link in answers so others can run and inspect your code with ease.

    – Khuldraeseth na'Barya – 2018-03-13T00:32:59.030

    2

    Meq, 145 111 bytes

    .==++>:+>+>[:++++++++>]:=+>====++++>===++>.===+++++++>:=+>:=++++>:++++++++>:>===+++rp>p>>p>p>p>p>p>p>p>p>p>p>p!
    

    Thanks Steadybox for saving 34 bytes

    DIDIx13

    Posted 2015-08-28T12:23:59.027

    Reputation: 137

    Welcome to PPCG! As far as I can tell, this is just the HW from the esolangs page (which seems to print Hello World) with two characters dropped. Does this actually print the correct punctuation of Hello, World!? – Martin Ender – 2018-03-16T09:41:39.063

    @MartinEnder It does not, it prints Helo World. (And the original prints Hello World.) – Ørjan Johansen – 2018-03-16T09:56:38.323

    1.==++>:+>+>[:++++++++>]:=+>====++++>===++>.===+++++++>:=+>:=++++>:++++++++>:>===+++rp>p>>p>p>p>p>p>p>p>p>p>p>p! should work. – Steadybox – 2018-03-16T10:37:58.857

    2

    Shakespeare Programming Language, 926 835 bytes

    Thanks to @JoKing for -91!

    CW'd. At present, the only SPL answer is completely ungolfed and has been so despite comments from last June, so I thought I'd post the RosetTIO answer (with modifications). I couldn't figure out the original author (perhaps this GH user? Who's that on SE?); if this is your work, I'll happily delete (or ask a mod to transfer post ownership and un-CW or something).

    a.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:You big big big cat!Puck:You is the sum of I the square of I!Speak mind!You is the sum of you twice twice I!Ajax:You is the sum of a big cat a cat!Puck:You is the difference between you I!Speak mind!You is the sum of the sum of you I a big big cat!Speak mind!Speak mind!You is the sum of you I!Speak mind!Ajax:You big big big big big cat!You is the sum of the sum of you a big big big cat a big big cat!Speak mind!You big big big big big cat!Speak mind!You is the sum of the difference between I you a big big big cat!Speak mind!You is the sum of a big cat a cat!Puck:Speak mind!You is the sum of you I!Speak mind!You is the difference between you twice I!Speak mind!You is the sum of you a big big big pig!Speak mind!You is the sum of a cat a big big big big big cat!Speak mind!
    

    Try it online! 46 warnings, but it does what it needs to do and sounds like Shakespeare[citation needed]. Yay.

    I wrote none of this; I merely removed from the RosetTIO program some unnecessary stuff. I outgolfed nothing (just shortened), so this is not eligible for that one bounty.

    Changes

    • [Exeunt] at the end removed
    • Linebreaks removed
    • thy in Speak thy mind! removed
    • as big as in You is as big as removed
    • and removed
    • myself and thyself replaced with I and you, respectively

    Khuldraeseth na'Barya

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 888

    as big as = is – Jo King – 2018-04-09T05:30:33.543

    somebody1234 is me, but I'm pretty sure I basically stole it from somewhere else lol – ASCII-only – 2018-04-11T02:58:27.527

    2

    Euphoria, 23 bytes

    puts(1,"Hello, World!")
    

    The (1, parameter tells the puts function to send the output to STDOUT, and there is no carriage return or EOL character for this one line program. This program will work as-is on both RDS Euphoria (v3.1.1 - last commercial version) and OpenEuphoria (v4.1 - current opensource version). The code omits the "optional trailing newline" (per the challenge rules) or else it would be two characters longer (adding \n after the !).


    I am surprised that no one had added Euphoria to this challenge before now but I am glad that I could as I really like this powerful little language. Since no one added it to this list after more than 2 years I am thinking that maybe CodeGolfers never heard of Euphoria? I am not sure if it is okay to do this here but what follows is a very short description of the language for context. If this is not okay I apologize in advance. Also, where would such information be appropriate? Is there a "directory" of languages post somewhere in the site?

    Euphoria was released in 1995 (back in the days of DOS and Windows 3.1) with only two data types: the atom (each contains a single number) and the sequence (essentially a dynamically-sized array of zero or more atoms). Two other types (the integer and the object) were added in recent years to help with efficiency of execution. One of the most interesting things that attracted me to this language long ago besides its remarkably uncomplicated structure is that it runs incredibly fast for an interpreted language. Also it has engines that run on Windows, Linux, and Mac OSX so user code is cross-platform.


    PS: It seems as of the time of this posting that the original RDS website linked above is down due to hosting problems after 20 years with the same host. It is unclear when (or if) it will come back up. However the rather extensive library of user created programs for the language is archived here if anyone is wanting good sample code to explore the language.

    Mathew Ambrose

    Posted 2015-08-28T12:23:59.027

    Reputation: 21

    2

    Zig, 81 bytes

    pub fn main()!void{try(try@import("std").io.getStdOut()).write("Hello, World!");}
    

    Try it online!

    Okx

    Posted 2015-08-28T12:23:59.027

    Reputation: 15 376

    This looks like an interesting language. The author appears to be aware of TIO! – Esolanging Fruit – 2018-05-09T04:09:46.700

    2

    2DFuck, 157 150 bytes

    .!.!..!.!....!..!..!.!.!.x[!.!..!.!..!..rv].!..!.!....!..!.!.!..!....!.!......!.!.!.!.!...!.!..!.!....!.!...!..!.!..!..!.!..!...!..!..!.!....!.!....!.
    

    Try it online!

    Print He, print l twice, print o, World!

    wastl

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 683

    2

    Ahead, 17 bytes

    "!dlroW ,olleH"W@
    

    A (very-unfinished at the time of this writing) fungelike. This works on the current master version.

    Ahead is my first esolang (well... that actually has progress). It borrows a lot of concepts from Befunge and ><> but hopefully it provides enough unique features to be interesting. I particularly want to provide features that can improve code density and golfing, one of which is included in this answer.

    W is called "Writewhile". This pops cells from the stack and prints them as chars, until it encounters a 0. The 0 is popped and discarded (not printed). Since stringmode pushes a 0 to the stack when it starts, this makes printing strings rather easy.

    "!dlroW ,olleH"    push chars to stack
                   W   pop and print until 0
                    @  kill head
    

    Try it online!

    snail_

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 370

    2

    ObCode, 68 bytes

    Hexdump:

    0000000: 9a62 c6c6 ca78 b665 a999 4ea9 5995 aa66  .b...x.e..N.Y..f
    0000010: 53a9 6363 6665 3958 d996 a539 6363 6565  S.ccfe9X...9ccee
    0000020: 6363 6656 5396 3636 3656 65a9 9594 ea8d  ccfVS.666Ve.....
    0000030: 9599 6aa5 6339 6395 9599 594e 5656 5665  ..j.c9c...YNVVVe
    0000040: aa99 94e5                                ....
    

    Explanation

    Unpacking the program gives the following object:

    ((())()(())((()())((())())((())())(()()(())))((()())())(())(()())()()(())(())(()()(()))()()()(()()())(())(()()())()()()(())(())(()()(()))()()(()())((())())((())())(())(())(()()(()))(()()())((())())(())(()())()()(()()(()))(()())((())())((())())(()()())(()()())((())())((())())(())(()()())(()()(()))(()())((())())((())())((())())(()()())(())(()())()()(())(()()())(()()(()))()()()((())())(()()())(())(()())()()()()(()()())((())(()))(()())((()))(()()())(()()())(())(()()())(()()(()))(()()())(()()())(()()())(())(()())()()()()(())(())(()()(()))(()()()))
    

    Indented and commented, this gives:

    ( Start of main object
        (()) Define () (()) doing: (
            (()()) Save top stack value to register
            ((())()) ((())()) Push twice
            (()()(())) Concatenate
            This code will double an object
        ) ((()())())
        (()) (()()) Push 2
        () () Double it twice, producing 8
        (()) (()) Push 1
        (()()(())) Add: 8 + 1 = 9
        () () () Double thrice, producing 72
        (()()()) Output 72 = 'H'; Stack: empty
        (()) (()()()) Push 3
        () () () Double thrice, producing 24
        (()) (()) (()()(())) Add 1, producing 25
        () () Double twice, producing 100
        (()()) ((())()) ((())()) Duplicate and save to register
        (()) (()) (()()(())) Add 1, producing 101
        (()()()) Output 101 = 'e'; Stack: 100
        ((())()) Load 100 from register
        (()) (()()) Push 2
        () () Double twice, producing 8
        (()()(())) Add 100 + 8 = 108
        (()()) ((())()) ((())()) Duplicate and save to register
        (()()()) (()()()) Output both 108 = 'l'; Stack: 100
        ((())()) ((())()) Load 108 twice
        (()) (()()()) Push 3
        (()()(())) Add 108 + 3 = 111
        (()()) ((())()) ((())()) ((())()) Triplicate
        (()()()) Output 111 = 'o'; Stack: 100, 108, 111, 111
        (()) (()()) Push 2
        () () Double twice, producing 8
        (()) (()()()) Push 3
        (()()(())) Add 8 + 3 = 11
        () () () Double thrice, producing 88
        ((())()) Load 44, saved by the last doubling
        (()()()) Output 44 = ','; Stack: 100, 108, 111, 111, 88
        (()) (()()) Push 2
        () () () () Double four times, producing 32
        (()()()) Output 32 = ' '; Stack: 100, 108, 111, 111, 88
        ((())(())) Use 88 as new stack
        (()()) Load 1
        ((())) Exit the stack which is now 87
        (()()()) Output 87 = 'H'; Stack: 100, 108, 111, 111
        (()()()) Output 111 = 'o'; Stack: 100, 108, 111
        (()) (()()()) Push 3
        (()()(())) Add 111 + 3 = 114
        (()()()) Output 114 = 'r'; Stack: 100, 108
        (()()()) Output 108 = 'l'; Stack: 100
        (()()()) Output 100 = 'd'; Stack: empty
        (()) (()()) Push 2
        () () () () Double four times, producing 32
        (()) (()) Push 1
        (()()(())) Add 32 + 1 = 33
        (()()()) Output 33 = '!'
    ) End of main object
    

    wastl

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 683

    I don't understand why anybody cares about this language .__. – Esolanging Fruit – 2019-02-02T18:32:45.273

    2

    Xanathar, 24 bytes

    printf["Hello, World!"];
    

    Xanathar is a work in progress language, so it is rather hard to use.

    Compilation:

    $ xanathar helloworld.xan
    $ ./helloworld.xan.o
    

    NoOneIsHere

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 021

    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' + "!");
    

    Skidsdev

    Posted 2015-08-28T12:23:59.027

    Reputation: 10 009

    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.

    ry00000

    Posted 2015-08-28T12:23:59.027

    Reputation: 21

    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.

    Sagittarius

    Posted 2015-08-28T12:23:59.027

    Reputation: 433

    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.

    squid

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 482

    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
    

    Nissa

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 476

    2

    Java, 82 bytes:

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

    user90364

    Posted 2015-08-28T12:23:59.027

    Reputation: 55

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

    user85052

    Posted 2015-08-28T12:23:59.027

    Reputation:

    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
    

    pppery

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 592

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

    user85052

    Posted 2015-08-28T12:23:59.027

    Reputation:

    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>
    

    user92069

    Posted 2015-08-28T12:23:59.027

    Reputation:

    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

    Dion

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 372

    2

    AdamS

    Posted 2015-08-28T12:23:59.027

    Reputation: 346

    2

    evil, 70 bytes

    aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw
    

    Try it online!

    AdamS

    Posted 2015-08-28T12:23:59.027

    Reputation: 346

    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!
    

    manatwork

    Posted 2015-08-28T12:23:59.027

    Reputation: 18 847

    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";
    

    ceilingcat

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 225

    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