text:
"Hello, World!"
So... uh... this is a bit embarrassing. But we don't have a plain "Hello, World!" challenge yet (despite having 35 variants tagged with hello-world, 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 = '
' + c.body.replace(OVERRIDE_REG, '') + '
';
    });

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

<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">

Shortest Solution by Language

Language	User	Score

Leaderboard

	Author	Language	Size

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Must the language meet our usual requirements for what a programming language is, or are we operating by kolmogorov complexity rules?

@isaacg No it doesn't. I think there would be some interesting languages where it's not obvious whether primality testing is possible.

If the same program, such as "Hello, World!", is the shortest in many different and unrelated languages, should it be posted separately?

@aditsu Yes, because there's no way anyone to find to the shortest version in an answer of an unrelated language.

Is there a way to make the snippet runnable without having to click "Show code snippet" first?

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

@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?

Or the non-minified code could be included in the post in a html comment.

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

@MartinBüttner Oh, right, didn't catch that the first time. Thanks!

This solution of mine causes graphical glitches in the scoreboard when the score is added.

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

Can you assume that there is no input?

@LegionMammal978 Yes.

Each submission must be a full program. ... pleace enforce this! Obeying this rule creates a handicap as long as solutions ignoring it are tolerated.

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

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

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

@MartinBüttner Thanks, Mathcad answer added.

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

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

Damn, i was 20 minutes late! :P

Noooo c'mon fastest gun in the west effect ;)

@Shebang Did you create the language just so you can win puzzles like this?

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

I've been trying to come up with a shorter solution, but I'm stuck.

@Shebang 20 minutes, 150+ upvotes. I kinda feel for you

Also a polyglot with Bound

I challenge you with this question: https://codegolf.stackexchange.com/questions/240385/invent-new-programming-language-and-write-hello-world-in-it :)

Haha, "stuck". Get it?

PHP, 13 bytes
Hello, World!

Yes. It works.
Try it online!

As usual with PHP, you always wonder how it can work

It works, of course, because there's no <?php in the code, causing it not to get interpreted by PHP at all :)

That means this is just an HTML answer...

@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

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

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

trying this out via CLI with php -r "Hello, World!" results in an error.

See, when I did this, I got a -1, not +173

@StanStrum Because then it would be a duplicate of this answer

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

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

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

That looks more like a cat script to me!

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):
\$f_n=171(-f_{n-1}-f_{n-2}-f_{n-3}+1)\$, with \$f_0=57, f_1=123,f_2=167\$
The factor of \$171\$ arises because \$3^{-1}=171 \pmod{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:
\$f_n=c_1f_{n-1}+c_2f_{n-2}+c_3f_{n-3}+\cdots+k\$
with
\$f_0=s_1, f_1=s_2+c_1f_0+k,f_2=s_3+c_2f_0+c_1f_1+k,\text{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 \$f_n=2f_{n-1}-f_{n-2}+1\$, with \$f_0=0,f_1=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:

Total length of the program found, and the initialization segment.
Path taken, starting with the current tape pointer. Each node corresponds to one character of output, represented as (pointer, cost).
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:Surpassed by @KSab (72)
--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.

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

Non-wrapping, 80 bytes (previously 92 bytes (mitchs)):Surpassed by @KSab (76)
-[[<]->+>>>>+>+>+>+>+>+]>>>>+.>>>++.<++..<.<<--.<+.>>>>>>--.<<<.+++.>.>-.<<<<<+.

Hello, world!
Wrapping, 80 bytes:Surpassed by @KSab (77)
++<-[[<+>->+>--->-<<<]>+++]>+.<<<<<<<++.>>>..>.<<--.<<<--.>>+.>>>.+++.<.<<<-.<+.

Non-wrapping, 81 bytes (previously 92 bytes (hirose)):
+>---->->+++>++>->+[++++++++[>++++++++>>+++++<<<-]<]>>.>++>.>..+>>.+>-->--[>-.<<]

hello, world!
Wrapping, 74 bytes:Surpassed by @KSab (70)
-<++[[<+>->->+++>+<<<]->]<<.---.<..<<.<<<---.<<<<-.>>-.>>>>>.+++.>>.>-.<<.

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:
-[>>+>+[++>-<<]-<+<+]>---.<<<<++.<<----..+++.>------.<<++.>.+++.------.>>-.<+.

This is great! Got the small-w version down to 82 :) +>---->->+++>++>->+[++++++++[>++++++++>>+++++<<<-]<]>>.+>++>.>..+>>.+>-->--[>-.<<]

This is nuts. One of you should submit the 82-byte version to anarchy golf.

The best Java solution to this question is 76 bytes. Only 9 more bytes to go to prove Java developers should switch to Brainfuck.

@LevelRiverSt The small-letters one is 2 bytes shorter than Java. The endtimes have come.

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

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

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

@dorukayhan main(){puts("Hahaha");}

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

@OlivierGrégoire that's a really outdated version of Java though, who uses that in production anymore :P

@ASCII-only I know a few companies...

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

Just for lols...
Try it online!

Worked for me. Try putting it's showtime on the first line and you have been terminated on the last line

I really need to learn how to use this language.

Doesn'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 It worked for me like this :D

@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 thank your very much, I try to be as professional as possible with ArnoldC the language of the future!

The string should be Hello, World!

IT'S SHOWTIME! TALK TO THE HAND. YOU HAVE BEEN TERMINATED.

Seed, 6016 4234 4203 bytes
20 [encoded data, 4200 characters]

Try it online!
The resulting Befunge-98 program (based on this) is
"9!dlroW ,olleH"ck,@

Try it online!

Very 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 Oops LOL.

Wow! How did you find this?

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

What. That's insane.

HOW DID YOU GOLF THIS?

Did you reverse engineer the mersenne twister? And does this have any security implications?

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

Inquiring minds want to know !

@feersum We demand to know.

I 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 If you're still interested in the problem, you could try to crack this.

I'll give you another +500 for a detailed (theoretical) explanation.

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

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

I think I'll pitch in +250 along with @primo

@ConorO'Brien As will I

Trying to golf this... Estimated time: 511576891064129323642698858496 days, 18 hours

My 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()

Explanation plz!!

Please. How did you do this?!?!?!?!?!

Still no explanation. I'm beginning to lose hope :(

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

@SpenserTruex This is not a good description of my algorithm.

@feersum Then why not give one? ;)

I guess it's because feersum likes to get these monthly reminders that he/she is smarter and wiser than everyone else... :)

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

Please, 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

@TehPers how did you get the states?

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!

This could actually be useful for my programming language

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

Absolutely INSANE. I saw this lang on esolangs.org 1 time, but I forgot about it.

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.

This is absolutely brilliant :D

I love this language. Excuse me, while I do systems programming in this language.

Where on EARTH has this language been all my life?

@ScottMcGready between Camden Town and Euston.

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

Pushing this to production...

3572 bytes

@NieDzejkob what did you golf? Is it just some minor changes?

@MartinEnder just using shorter Line names where possible

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

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

What the heck is this language?

Do I recognise the names of the London Underground "tube" lines?! xD

Nice job! You beat Seed!

@MartinEnder This program may be on thin ice -- they're bound to change the last remaining signs at Heathrow Terminals 2 & 3 station to match the current name sooner or later...

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.

How on Earth did you find this?

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

Hey you beat Java.

@KSab I wonder if this is optimal

That's some device, it doesn't even require wrapping cells ó_Ò

This is extremely impressive! For reference, the initialization loop leaves the tape as ...35 42 87 106 99 72 35 (0)...

Would love to see the algorithm behind this :)

Are those other shortest solutions from a source that is not your brain? If so, can you post those sources?

@EngineerToast sorry for the unclear wording, I did find those using the same method as the main solution

@Poke No, they don't beat Java

Explain! (please.)

I like how this uses a loop even during the "find and print" second half of the program.

When are you going to explain it :P

We want an explanation!

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

Does someone still have bfbrute's source code? Github link is down.....

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

That is evil...

Especially since your avatar is Black Hat.

can u explain me the interweave process.

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

@KishanKumar yes

@grc thanks. Any offline compiler will also be great

@KishanKumar there's a java implementation here.

If you read this program out loud, it sounds like a dubstep bass.

Piet, 90 codels

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

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

Trying to take your own bounty? I thought more of you Sp3000 ;)

Hah, just because I set a bounty doesn't mean I can't join in the fun :P

Have a +1 anyway. I love Piet

This is the smallest Piet "Hello, World!" that I've seen.

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.

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

oh i didn't realize it was, as I always used PietDev.

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.

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

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

What the hell is this "language"? I love it!

"push-pop no-op" is now my favourite phrase

Modern international spies must use this language.

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.

@MegaMan Base 18 encoding would take 47 bytes, plus 2 bytes for dimensions  makes 49. A better compression probably exists.

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

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|

Try it online!
Bonus: A more exciting version:
v      >;+o|
v      "
v      !
v      d
v      l
v      r
>>"Hello, ">>>v
       W      v
       "      v
       ^<<<<<<<

Just out of curiosity, what happens if you include one of the characters in a string?

@Random832 In a string, directional characters are treated as regular characters, i.e. you can include them in a string.

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

Most entertaining solution here; this one wins.

;+o

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

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

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

Hahaha well done for creating the most useful golfing language ever :D

So, HQ9++, essentially, eh? ;-)

@TimmyD Nope, not HQ9++.

Oh for crying out loud. Is there anything that isn't an esolang at this point? :)

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

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

And 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?!

@LevelRiverSt I was going to upvote your comment, but it has 42 upvotes.

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

MarioLANG, 259 249 242 240 235 bytes
+>+>)+)+)+++)++++((((-[!)>->.
+"+"===================#+".")
+++!((+++++++++)++++++)<.---+
++=#===================")---.
++((.-(.)).+++..+++++++.<---
 !+======================---
=#>++++++++++++++.).+++.-!>!
  =======================#=#

Try it online!
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.

@justhalf You should see my Pada answer. :P

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.

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.

This language is so metal.

If we had to list programming languages in order of evilness, Dark would top evil.

there is hell in hello

super evil, you can even raise an army of walking gotos

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

Try it online!
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.

This is...weird...

I haz found a new favorite salmon-powered universe destroyer...uh...I mean "Hello, World!" program. +1

Every time I come back to this, I have a good laugh. Thanks for creating possibly the most entertaining Hello, World! program of all time.

This is my new favorite language.

https://tio.run/#homespring

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.

Try it online!
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.

If anyone could golf in Chef it's Sp.

Now try golfing recipes in real life. :D

Lol, this is not only not good to eat, but also uses non-standard measuring units. XD

Piet, 84 codels

28x3, here shown with codel width 10.
Created with PietDev (zip), tested with npiet. The layout of the program is the following:

Yellow fill indicates codels where the path overlaps, orange fill indicates codels which must be the same color, for purposes of control flow.
To aid in the creation of this, I wrote a rudimentary interpreter for a stack-based language with piet-like commands, which I have dubbed "pasm" (source). The output from this interpreter (with this input) is the following:
    1 nop     blu1 []
    4 push 3  blu2 [3]
    5 dup     grn2 [3, 3]
    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.

Congrats, you got my bounty :)

@LegionMammal978 Thanks, it was fun to work on. And merry christmas :)

This is what hollywood should show on "hacker" screens.

Your pasm source link is dead.  But I like the whole idea.  Can you put the source somewhere accessible?

@JerryJeremiah rehosted. The reason for making this, is that I had to ensure that 53 and 55 were both the same color and shade, as well as 27 and 79.

HTML, 13 bytes
Hello, World!

The text is automatically inserted into the , and is displayed.

Wow. That's some really hardcore coding skills

@JonasDralle at least it does what you'd expect!

HTML is not a programming language, but a markup language (that's why it ends with ML).

But HTML isn't printed in STDOUT.

-1 HTML Doesn't meet the requirements for a valid language

HTML doesn't print to STDOUT

HTML doesn't stop people not refraining from repeating each other. It's just a markup language!

@Doᴡɴɢᴏᴀᴛ Since this is a constant output challenge, languages that don't meet our usual requirements for a programming language are allowed.

HTPL, anyone???

-1 not enough jQuery

This is a polyglot, also works in plaintext!

@CoDEmanX: By that logic, is ML a markup language?

@Mark Hmm, rather "ML in HTML stands for markup language"? Although a markup language = a markup language (as in identity definition?)

@CoDEmanX: I meant the language called ML (by Robin Milner and others), but it wasn't really serious :-)

ML can also mean "meta language", which is the same as programming language IIRC

Also works in Text

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

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 () is selected, this assumes that we're using the most basic HTML document, i.e.

This works in most major browsers, with the notable exception of Firefox, which applies the selector to the  and  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!"

You can also use * * to select body.

@jimmy23013 That sounds gloriously inefficient. Thanks

For whatever reasons * :after also seemed to work.

@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 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 Yeah, I agree. It isn't intuitive that you apply ::after to the element you want to insert the content into.

I'm asking my self which of the letters in CSS is the abrreviation for "language".

@zaibis the same letter for PHP probably :)

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

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

Try it online!
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.

The static block trick resulted in something being written to stderr, which is not acceptable here.

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.

Use enum instead of class.

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

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

Processing (also java): print("Hello, World!");

@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 That's why I didn't post it as an answer.

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

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.

U may be able to use interface than a class in Java 8

Beaten by TheNumberOne's answer with -3 bytes.

@StevenVascellaro ... which in turn is beaten by my answer with -14 bytes.

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

Try it online!
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.
..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
...>>.>.>>;
>...>;
..;
.;
;

Try it online!
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

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.

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

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

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

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 [encoded data, 4151 characters]

Try it online!

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?

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

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

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

The output of the latest revision appears to be incorrect.

@Dennis I'm using the code suggested by Kevin. The deal is probably PyFunge98 is biased and can't run the valid code.

If you provide an explanation of how you derived your solution, I may bounty depending on how good the explanation is

@Szewczyk I'll award the bounty once you edit the link (or the entire post if it fits) into your answer

@user41805 the article is quite chonky, so I leave the link here

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.

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.

@user41805 would you mind granting the bounty before it expires?

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

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.

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

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

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.

NASM source for 30 byte version (checked size on my desktop), https://tio.run/##TY8/b8JADMX3fIpXxEZSkaJ2gAl16YAAdekY@XpWdJKTU@MjkE8fDq608eJ/zz89kyo3RoaiJW3GsRZvSFBpoC5kKa0zoPE9QJIDJWJsUFX7z@rcucCPLVuXg@mCJFDqOYrNEBi9Jo11kVA@DuwN12gt3P4xNDLi6JexeimMCyCjXk6RQ9Z2rOra@o7Xf/4zXot7@b7d7bBAmbrj4RjROug3iWSTP96WwOQRvrgwEUYHa1iD2QeL@BxfvhP7NMuSWfDPCXMUN6PjeAU

save a quick byte by removing mov dil,0x1 and putting in mov edi,%eax after the mov al,0x1.

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.

Dammit, you beat me to it. I myself am working on a hexagonal language kind of similar to Cardinal.

How did you find this solution? By hand or brute-force? Anyway, +1 :)

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

The Q2, P0 and P1 is very clever. I didn't know the modulo 256 part.

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

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

Note: This was reduced to 31 a while ago. H;e;P;2Q/d;l;r/l;$@;o];o;W;03&;

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

Try it online!
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!

It'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: for the former, main(){return!puts("Hello, World!");} is two bytes shorter.

The 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 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 ;)

Actually, by 2017 rules those would be 34 and 38 bytes respectively.

main(){puts(_FILE_"!");} with a file name of "Hello, World" is 26 bytes.

@Random832 for the latter int puts();int main(){puts("Hello, World!");} is 45 bytes, +5 if char* is required

Fourier, 15 bytes
BIG CHANGES to Fourier!
`Hello, World!`

Try it on FourIDE!
Yes, the days of typing out the ASCII code of each character are gone forever: Fourier now kind of supports strings. When you enclose a string in backticks, that string will be outputted.
Note that you can't do anything other than output that string: you cannot store it in a variable, it is not stored in the accumulator and there are no string manipulation tools.

Here, you can find the train wreck that was old Fourier. ;)
72a101a+7aa+3a44a32a87a111a+3a-6a-8a33a

Try it online!
Now, some of you will probably have met Fourier before and may be fairly familiar with the language. The whole language is based upon an accumulator: a global variable which pretty much all operators use.
The most important part of the code is the a operator. This takes the numerical value of the accumulator and converts it to a character using the Python code chr(accumulator). This is then printed to STDOUT.
Unfortunately, I haven't had the chance to use Fourier yet (nudge nudge, wink wink), mainly because of its lack of strings and string operators. Even so, it's still usuable for many other challenges (see the examples section of its EsoLangs page).
Note that this is shorter than my entry into the Esolangs list because I didn't actually think that I could golf it any more. And then, when writing the Fourier string golfing challenge, I realised I could go quite a bit shorter.
Note
If you were wondering about variable syntax, Geobits wrote a program which uses variables and is the same length:
72a101a+7aa+3~za44a32a87aza+3a-6a-8a/3a

Try it online!

What's a usuable? Is it like a usable?

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

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

@TimmyD It's really an assembler. There's a reason it loses to Java... :)

I 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 Indeed I tried using their Cmm backend directly before, but I had some weird issues and never really looked into it much further ¯\_(ツ)_/¯

You can probably get some help on the Haskell mailing lists. Try glasgow-haskell-users@haskell.org, or perhaps haskell-cafe@haskell.org.

Java 5, 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 this solution uses a bypass[1] that 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!
$

The bypass consists of the static execution of code when the class is being linked. Before Java 7, the main-method-containing class was no exception to the static initialization code. Afterwards, static initialization was delayed until the main method would actually be found.

I recommend changing the title to “Java 6, 62 bytes” to clarify the version requirement. I’d also like to ask for more detail on the “bypass” fixed in Java 7.

@StevenVascellaro Explanations have been added.

The 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

@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?

@OlivierGrégoire Nice job ;) Also, I changed my program's header to Java 8 when I saw the comments here.

Uh, this is actually 61 bytes

@cairdcoinheringaahing Oops, thank you, I fixed it.

Isn't stderr ignored on PPCG? Wouldn't that mean that you can remove the System.exit?

@NieDzejkob The challenge explicitly says no to that interpretation.

Now beaten by a boring 47 bytes solution that Java 21 introduces.

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

How about this one?
('<;_#"~6Z|{y1UTvt,PrpMo,llj"Fgge{A??P=^t:8&7YtFVqjSQ@PNM)u(I8%$#"D2AA/[TYXQu88MLp3n1Gk.D-ge (92 bytes)

71 bytes

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.

What are you talking about? Its pretty readable!

@Optimizer Fixed.

Still readable! (of course I am telling the truth. Why won't you believe me?)

Feels like this language would benefit from a better huffman coding - both in terms of size, and unreadability.

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

Well it works in Chrome on Android

Works in Chrome on OS X too

@BetaDecay @C0deH4cker I think that's because of the  []["fill"]. Just updated my answer, thanks!

@Sp3000 Nice!!! Thanks ;) You could report that to JScrewIt as an issue.

Safari on OS X works too :D

You did a great job here! Be sure to check the last update.

@GOTO0 Wait... you are the author of JScrewIt, right?

How the hell do you call functions with this?

You don't, that's how.

shorter 3522 byte version: https://codegolf.stackexchange.com/a/229606/48718

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!

Why not use class?

@Joao-3 interface methods are public by default.

Oh, thanks for giving me a nice Java fact!

Shakespeare Programming Language, 755 749 715 612 605 592 bytes
-34 bytes thanks to jimmy23013
-And a whole 107 bytes more! Wow!
,.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:You big big big cat!Puck:You is the sum ofI the square ofI!Speak thy!You is the square ofthe sum ofI a big cat!Ajax:Remember the sum oftwice twice you a cat!Remember I!You is the sum ofI you!Puck:You is the sum ofyou a cat!Speak thy!You is the sum ofa big cat a cat!Ajax:Speak thy!Speak thy!Remember you!You is the sum ofyou I!Speak thy!Remember the sum ofyou I!Remember you!You big big big big big cat!Puck:You is the sum ofI twice twice you!Speak thy!Ajax:Remember the sum oftwice I a pig!Scene V:.Ajax:Speak thy!Recall!Let usScene V!

Try it online!
Non-erroring version, 626 bytes
,.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:Remember I!You big big big cat!Puck:You is the sum ofI the square ofI!Speak thy!You is the square ofthe sum ofI a big cat!Ajax:Remember the sum oftwice twice you a cat!Remember I!You is the sum ofI you!Puck:You is the sum ofyou a cat!Speak thy!You is the sum ofa big cat a cat!Ajax:Speak thy!Speak thy!Remember you!You is the sum ofyou I!Speak thy!Remember the sum ofyou I!Remember you!You big big big big big cat!Puck:You is the sum ofI twice twice you!Speak thy!Ajax:Remember the sum oftwice I a pig!Scene V:.Ajax:Speak thy!Recall!Be you nicer zero?If solet usscene V!

Try it online!
An improvement over the previous community wiki answer.
Explanation:
,.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]   #Initialise Ajax and Puck

Ajax:You big big big cat!                    #Set Puck to 8
Puck:You is the sum of I the square of I!    #Set Ajax to 8+8*8=72 ('H')
Speak thy!                                   #Print 'H'
You is the square of the sum of I a big cat! #Set Ajax to (8+2)^2=100 ('d')
Ajax:Remember the sum of twice twice you a cat! #Push 2*2*8+1=33 ('!') to Puck's stack
Remember I!                                  #Push 'd' to Puck's stack
You is the sum of I you!                     #Set Puck to 100+8 ('l')
Puck:You is the sum of you a cat!            #Set Ajax to 100+1=101 ('e')
Speak thy!                                   #Print 'e'
You is the sum of a big cat a cat!           #Set Ajax to 3
Ajax:Speak thy!Speak thy!                    #Print 'll'
Remember you!                                #Push 'l' to Puck's stack
You is the sum of you I!Speak thy!           #Set Puck to 108+3=111('o') and print it
Remember the sum of you I!                   #Push 111+3=114 ('r') to Puck's stack
Remember you!                                #Push 111 ('o') to Puck's stack

You big big big big big cat!                 #Set Puck to 32 (' ')
Puck:You is the sum of I twice twice you!    #Set Ajax to 32+12=44 (',')
Speak thy!                                   #Print ','
Ajax:Remember the sum of twice I a pig!      #Push 2*44-1=87 ('W') to Puck's stack
Scene V:.Ajax:Speak thy!Recall!Let us Scene V!  #Print and pop repeatedly until Puck's stack is empty (', World!')

Impressive. Take another +1. This should win one of ASCII-only's bounties for improving the RosetTIO solutions.

Ah, just noticed the no stderr rule, so the 622 byte version is probably invalid.

@jimmy23013 Eh, we already had 43 warnings in stderr, I think we're good. Very nice work!

@JoKing They were all compiler messages and it was not the program itself writing to stderr. But this time a runtime error.

Let us Scene V works.

@jimmy23013 I've added a non-erroring version

For some reasons nobody has noticed yet you had a "remember me" instead of "remember I" in the non-erroring version.

Right, weird... >.<

Pada, 83 68 bytes
~.O~Ow~q~Owo~O~Oww~Q~qwo~q~O~wQ~q~w~q~q~Q~Ow~Q~Q~wo~q~w.~q~w.~.wO~qw

I believe this is optimal for a linear program (i.e. one which doesn't use the control flow operators ? and *). It might be optimal overall, but I don't know how to go about making use of those additional operators in such a small amount of code (or how to explore the possibilities programmatically).
The language has recently undergone some changes after I started discussing it with the author by email. However, I have written a reference implementation for the current state of the language spec last week, so the above code is actually runnable.
Metagolf
Originally, I had used the output of my reference implementation to this challenge and created a hand-crafted solution based on that. However, that was just a heuristic approach.
So instead I wrote a solver in Mathematica which actually knows about the Pada data structures and operators to find an optimal solution. On average, it grows linearly with the length of the string (although some character combinations are a bit slower than others) and took about 1.5 hours for Hello, World!.
So how did I go about writing the solver. First, we notice that we only need to consider 6 operators: ~.oOqQ (plus the necessary w for each of the printed characters). Using the stacks or the bit locks isn't useful in linear code, and I don't believe that ? and * can be used effectively in less than 68 bytes.
Pada's state (ignoring the stacks and locks) consists of 7 switches and 8 bits, arranged like this:
       /
   /       \
 /   \   /   /
0 1 0 0 1 0 0 0

So that's 215 = 32768 possible states. My first preprocessing step was to set up a directed graph of states where each edge corresponds to a single operation. That is, the graph has 32768 vertices, each with out-degree 6 (one outgoing edge for each of the 6 operations under consideration). We can use this graph to find the shortest path between any two states (this graph alone can be quite useful for golfing Pada).
Now for each character, we want to reach a state where w prints that character. How many such states are there? w reads the byte from the bit it is dropped on (cyclically). So there are 8 possible rotations of the bits of the character which can all print that character. For each of those rotations, three switches are fixed (in order to make w drop in the correct position). This leaves 4 arbitrary switches. So we've got 8 * 24 = 128 possible states for each w in our code.
With those we can solve another graph problem: construct a graph which has a source vertex, then one "layer" for each character, and a sink vertex. The layers consist of the 128 states for each vertex, the source node corresponds to the initial state of the program (all switches to the left and all bits are zero). The sink node corresponds to no state in particular. We've got directed edges from every vertex in one layer to every vertex in the next layer, where the edge weight is the distance between the two states in our earlier graph. The weights of the edges from the last layer to the sink are all 0. That is, we can precompute all those edge weights. This is the most expensive step of the computation and took 1.5 hours for Hello, World!.
With this graph set up, we can find the shortest path from the source to the sink quite quickly (it took 0.05s on my machine). For Hello, World! the desired states are:
0, 16960, 22052, 13828, 13828, 30389, 12487, 8307, 27299, 23450, 18922, 22778, 18682, 18459

where the least significant 7 bits correspond to the switches and the most significant 8 bits to Pada's bits.
Now we go back to the first graph and find the actual edges (i.e. operations) corresponding to the shortest path between each pair of subsequent states, and end each of them with a w. Voilà, an optimal solution (based on the above assumptions).
Here is the full Mathematica if anyone ever wants to metagolf a different string in Pada:
string = "Hello, World!";
width = StringLength@string;
getState[letter_, state_] := (
  {shift, switchState} = IntegerDigits[state - 1, 16, 2];
  bits = RotateRight[
    IntegerDigits[ToCharacterCode[letter][[1]], 2, 8], shift];
  switchState = IntegerDigits[switchState, 2, 4];
  switches = {-1, -1, -1, -1, -1, -1, -1};
  {top, middle, bottom} = IntegerDigits[shift, 2, 3];
  switches[[1]] = top;
  If[top < 1,
   switches[[2]] = middle;
   If[middle < 1,
    switches[[4]] = bottom,
    switches[[5]] = bottom
    ],
   switches[[3]] = middle;
   If[middle < 1,
    switches[[6]] = bottom,
    switches[[7]] = bottom
    ]
   ];
  For[i = 1, i <= 7, ++i,
   If[switches[[i]] < 0,
    switches[[i]] = First@switchState;
    switchState = Rest@switchState
    ]
   ];
  {bits, switches}
  )
encode[state_] := FromDigits[Join @@ state, 2]
decode[id_] := Partition[IntegerDigits[id, 2, 15], 8, 8, 1, {}]
getBitFromSwitches[switches_] := (
  If[switches[[1]] < 1,
   If[switches[[2]] < 1,
    1 + switches[[4]],
    3 + switches[[5]]
    ],
   If[switches[[3]] < 1,
    5 + switches[[6]],
    7 + switches[[7]]
    ]
   ]
  )
toggle[list_, index_] := ReplacePart[list, index -> 1 - list[[index]]]
stateEdges = Flatten@Table[
    {bits, switches} = decode@id;
    bit = getBitFromSwitches@switches;
    {
     Labeled[id \[DirectedEdge] encode@{bits~toggle~bit, switches},
      "~"],
     Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~1}, "."],
     If[switches[[1]] < 1,
      {
       Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~2},
        "o"],
       Labeled[
        id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~3},
        "q"],
       If[switches[[2]] < 1,
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~4},
         "O"],
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~5},
         "O"]
        ],
       If[switches[[3]] < 1,
        Labeled[
         id \[DirectedEdge]
          encode@{bits, switches~toggle~1~toggle~3~toggle~7}, "Q"],
        Labeled[
         id \[DirectedEdge]
          encode@{bits, switches~toggle~1~toggle~3~toggle~6}, "Q"]
        ]
       },
      {
       Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~3},
        "o"],
       Labeled[
        id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~2},
        "q"],
       If[switches[[3]] < 1,
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~6},
         "O"],
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~7},
         "O"]
        ],
       If[switches[[2]] < 1,
        Labeled[
         id \[DirectedEdge]
          encode@{bits, switches~toggle~1~toggle~2~toggle~5}, "Q"],
        Labeled[
         id \[DirectedEdge]
          encode@{bits, switches~toggle~1~toggle~2~toggle~4}, "Q"]
        ]
       }
      ]
     }
    ,
    {id, 0, 2^15 - 1}];
stateGraph =
  Graph[# & @@@ stateEdges, EdgeLabels -> Rule @@@ stateEdges];
uid = 0;
layers = Join[{{{uid++, 0}}},
   Table[{uid++, encode@getState[#, i]}, {i, 128}] & /@
    Characters@string, {{{uid++, -1}}}];
edges = Flatten[Table[
      from \[DirectedEdge] to
      ,
      {from, #},
      {to, #2}
      ] & @@@ Partition[layers, 2, 1], 2];
Timing[weights = (
     {from, to} = Last /@ List @@ #;
     If[to < 0,
      0,
      GraphDistance[stateGraph, from, to]
      ]
     ) & /@ edges;]
characterGraph = Graph[edges, EdgeWeight -> weights];
Timing[path =
  Last /@ Most@
    FindShortestPath[characterGraph, {0, 0}, layers[[-1]][[1]]]]
(PropertyValue[{stateGraph, #}, EdgeLabels] & /@
      DirectedEdge @@@
       Partition[FindShortestPath[stateGraph, ##], 2, 1] <> "w" & @@@
   Partition[path, 2, 1]) <> ""

An interesting language to do metagolf on =). This makes me wonder, what's your day job? o.O

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

Pada means when in bahasa Indonesia/Malay. Is that relevant?

@XiKuuKy afaik, the language is called Pada, because it means "falling" in Croatian.

And this answer to (see here ). You probably can combine 2 answers in one to describe this wonderful Hello World problem in general.

Pyth, 14 bytes
"Hello, World!

Doubt it'll get smaller than this in Pyth.

This also works in TI Basic

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.

Python 2, 20 bytes
print"Hello, World!"

Python 2 is better for printing than 3 :D

Just in case anybody is wondering: import __hello__ prints "Hello world!", which is incorrect punctuation for this challenge.

@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 Ah, I didn't realise Python 2 and Python 3 had different __hello__ messages, indeed I tested on the wrong one.

Python 2.7 prints Hello world... \o/ What is this!!!

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

I don't think 93 has k

@Sp3000 Checked the spec, you are right. I thought that p was missing. It's the opposite. Thanks.

Well, now that it's 98 only you can use c for 93+.

@Pietu1998 Indeed, nice one.

In 18: "ck,@!dlroW ,olleH

@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 ?

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

Didn't though of the wrapping around. Great little hack !

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

@Luke The second character should be d, not c. I don't know why but it fixes the bug primo pointed out.

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

@undergroundmonorail rcfunge gives the correct result with this exact code, and ck,  do it 13 times as per the specification

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.

even the befunge solution is boring :/

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.

I was hoping it wouldn't be brute-forced, but you still get the bounty

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

Any plans on posting the brute-forcer as well?

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

I'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

@user202729 did you ever get around to posting the brute forcer

@ASCII-only It's linked right there

I'm shocked that a solution even exists which only uses 3 prints.

Can we get an explanation of the code for those who don’t know Hexagony?

Has anyone tried adding unicode characters 288, 289, and 300 to the brute-forcer's search space?  it seems the trade off of an extra byte in the characters might allow for tighter packing and an ultimately shorter solution

@jeje I don't understand -- are those valid Hexagony commands? (Doesn't seem like it, in my reading of the specification)

Brainfuck, 92 (hirose)
->+++++>>>+>+>+>-->>++[+++[>++++++++<-]<+]>>.-[>->>>>>[+<]>--]>+>--.->---..>+++>.>>>++++[.<]

This is a slight modification of hirose's 92-byte solution for the lowercase-w version of the problem on Anarchy Golf.
Changing ++ to -- conveniently subtracts 32 from the cell that holds w, turning it into W.
Brainfuck, 95
->>++>+++>+>---->--[++++++[>+++++++++++<-]-<+]>>----.>+++.>-..+++.>>>.<.<.<.+++.------.<-.>>>+.

For this solution, I used code that I wrote for this problem on SPOJ and touched up the output a bit by hand.
Note: Both solutions are compatible with Alex Pankratov's bff (brainfuck interpreter used on SPOJ and ideone) and Thomas Cort's BFI (used on Anarchy Golf).

Here's the variant for a brainfuck derivative, oOo code: http://pastebin.com/BqNcDnm7 I'm not sure if it deserves its own answer. (It's based on the 92-char one you posted)

What is the advantage of the 95-byte solution? Why mention it at all?

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

(I was misinformed; it's 95 -> 96 and 92 -> 97 for ???.)

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!

Don't forget wrong caps :P

Jelly, 8 bytes
“3ḅaė;œ»

Try it online!

Wat. How on earth did you compress it so much...

Jelly now has an experimental decompressor that indexes an English dictionary.

Jelly is ḅaė.

you mean: ḅaė is jelly

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.

Crazy language, very nice answer.

94+3 bytes

Lost, 57 54 45 43 38 37 36 bytes
It's been a long journey here, but we've reached 36 bytes.  A 35 seems unlikely.
roW"\\ dl
<@+1(\
lo, /"Hel
%<<<\?<<<

Try it online!
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.
This draws on JoKing's 38 byte solution but is significantly more bizarre.
Explanation
This is a bit to messy to explain in a satisfactory way.
As is common with lost there's quite a few different execution paths and the art is tweaking it so every path works out just right.
Going over the program in general would skip a lot of things, but covering every execution path would be long and still seem unsatisfactory.
The best way to understand what is going on is to just try and make your own first.  But I will explain how this works in general.
Basic design philosophy
Unlike most 2d programming languages where a flat program is ideal because it avoids extra newlines.  In lost squarish programs are ideal.  This is because most lost programs employ a collection stream to catch all the wandering ips before they start actually executing.
The flatter it is the longer the stream has to be so that it can occupy every column.  This means that a square program minimizes the stream size.
However squares are kind of hard to program with in lost.  And there are some losses when trying to split linear logic onto several lines.  Earlier versions of this were flatter for this reason.  But this has managed to get pretty square.
The stream
The bottom row is a collection stream.  Pretty common for lost programs.  Regardless of where it initially starts the ip will eventually wander into the stream and start normal execution.
This is mostly just <.  These act as hard redirects and are what trap the ip.  There are three special things here %, \ and ?.  The \ is the exit.  It will deflect the pointer up and start our regular execution.  But since our normal execution expects a clean stack, we first need to clean up.
? pops a value off the top of the stack and jumps if it's not zero.  Since we can't push a zero this will jump until the stack is empty.  Since it's placed in front of the exit this means we are stuck in the stream until the stack is cleaned.
One issue is that ? is not a hard redirect so if the ip starts in its column it needs to end up in the stream some other way.  This was actually a significant hurdle in making the program work, but there are redirects in \ and / which just barely work out so it always ends up in the stream.
Then we also have %.  This turns the safety off so we can exit the program.  Since we need to do that eventually it's placed here.  Once again, it's not a redirect so it needs to be in a column with another redirect.  There is a < two rows above and that will eventually push the ip into the stream so that is covered.
Hello, /
Once we exit the stream we enter the first row.  The first row wants to push the string Hello, .  But we also want to save on quotation marks.  In lost we can potentially start and end a string with the same quotation mark, it just needs to start the string and then wrap around again to get back to it.  This will push everything on the line apart from the quote as a string.  This includes of course our entrance and exit, here a single /.  So we are going to end up with a slightly wrong string of Hello, /.  But as we deflect up we hit the ( which ditches the final character.  This ( is doing double duty and we will reuse it again in a bit.
World \
Once again we use a similar trick to push the second string we want, except this one is even wonkier.  We have three extra characters and are missing the ! still.
Since ! is such a painful character to deal with we want to avoid it altogether.  It's an unconditional jump so it really messes with whatever we want to do.  Instead we push a space   which is one less than a ! so we can increment it later.
That means that we spend 3 bytes to make !.  That's how awful it is to have a ! in your lost program.
As to why we have \\ it's a little more esoteric.  Obviously we need a entrance and an exit on the line, but last time they were the same character, why do we have them separate this time?
The thing is that if both lines have the same character to enter and exit then they would have to be in the same column.  Which would mean that we would have to end up right back in the stream where we started dooming us to an infinite loop.  So one of them has to have them separate so that we can finish in a different column than we started.  Here we are finishing in the ?'s column. ? is not a hard redirect so we can escape the stream.  Plus ? also gets rid of a character for us, just what we wanted to do!  But wait ? also skips over the " which would have been a big issue otherwise.1
The ? is doing a lot of work for this program.
Clean up
After the ? removes the first extra character, we land on the mirror \ which deflects us to the left.  And at this point we run right back into the ( from earlier.  This gets rid of our second extra character.  Now all that's left is to turn the space into a ! and exit and that's what we do.  We push 1, add it to the space and exit at @.

1: You might ask why we can't just move the " somewhere else.  The issue is that it can only be in one of two places on the left of the / or on the right.  But it also can't be in the same column as the other " otherwise they form a closed string and we get a nasty infinite loop.  So we end up having to put the " right there.

Common Intermediate Language, 126 123 bytes
.assembly H{}.method static void M(){.entrypoint
ldstr"Hello, World!"
call void[mscorlib]System.Console::Write(string)
ret}

With proper indentation:
.assembly H {}
.method static void M()
{
    .entrypoint
    ldstr "Hello, World!"
    call void[mscorlib] System.Console::Write(string)
    ret
}

You can save 2 bytes by removing unneccesary newlines (at least in Mono)

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.

wait, but alert does not print to STDOUT?

@James_Parsons Since JavaScript doesn't really have a traditional STDOUT, alert is typically considered acceptable.

oh, ok sorry. I'm kinda new here

@James_Parsons No problem. Welcome to PPCG!

console.log("Hello, World!") (28 bytes) outputs to STDOUT if run in node.

You may use Javascript Shell and change alert to print which will print to STDOUT.

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.

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

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.

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.

You know some of the weirdest esolangs.

Does it print to STDERR?

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

Minecraft 1.8.7, 26 + 2 = 28 Blytes
This is using this version of byte counting.

The command block contains the code:
tellraw @a "Hello, World!"
This one doesn't really need an explanation.

Use a button instead on this one.

This scoring method is called blytes (blocks + bytes).

@zyabin101 I know - I created the term. I hadn't updated it though. :P Thanks.

You couldn't have taken a screenshot during the day?

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

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.

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.

<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 210 105"><path d="M 20 80 L 20 100" fill="none" stroke="#FFC0C0" stroke-width="3"/><path d="M 20 8.5 L 20 80" fill="none" stroke="#C00000" stroke-width="3"/><path d="M 20 98.5 L 20 101.5" fill="none" stroke="#C00000" stroke-width="3"/><path d="M 180 30 L 200 10 L 199 10" fill="none" stroke="#C0C0C0" stroke-width="3"/><path d="M 200 10 L 10 10 L 30 30 L 30 50 L 40 60 L 60 60 L 70 50 L 70 30 L 60 40 L 60 70 L 50 80 L 50 90 L 60 100 L 70 100 L 80 90 L 110 90 L 90 70 L 100 60 L 120 60 L 130 50 L 130 40 L 120 30 L 120 70 L 130 80 L 200 80 L 180 60 L 150 60 L 180 30" fill="none" stroke="#000000" stroke-width="3"/><path d="M 10 10 L 30 30 L 30 50 L 40 60 L 60 60 L 70 50 L 70 30 L 60 40 L 60 70 L 50 80 L 50 90 L 60 100 L 70 100 L 80 90 L 110 90 L 90 70 L 100 60 L 120 60 L 130 50 L 130 40 L 120 30 L 120 70 L 130 80 L 200 80 L 180 60 L 150 60 L 180 30 L 200 10 Z" fill="none" id="move-loop"/><circle r="4" fill="#00C0C0"><animateMotion dur="10s" repeatCount="indefinite"><mpath xlink:href="#move-loop"/></animateMotion></circle></svg>

However, during the thirteenth and last iteration, the upper left corner if removed, so the particle moves down the red wire instead.
Code
As illustrated in the Stack Snippet, the particle takes the following left turns on the main wire.

315° Subtract. Nothing is done, since the stack is empty.
This turn, like the other no-ops, is made solely to save space.
45° Push 1. STACK: [1]
45° Push 1. STACK: [1 1]
45° Push 1. STACK: [1 1 1]
45° Push 1. STACK: [1 1 1 1]
135° Pop the stack. Since the popped element is 1, pop two more values (1 1) and push the code point of the character at those coordinates. STACK: [1 n]
Initially, the character at (1, 1) is -, so n = 45.
45° Push 1. STACK: [1 n 1]
315° Subtract. STACK: [1 (n-1)]
45° Push 1. STACK: [1 (n-1) 1]
45° Push 1. STACK: [1 (n-1) 1 1]
45° Push 1. STACK: [1 (n-1) 1 1 1]
45° Push 1. STACK: [1 (n-1) 1 1 1 1]
315° Subtract. STACK: [1 (n-1) 1 1 0]
135° Pop the stack. Since the popped element is 0, pop two more values (1 1) and store the next value on the stack (n-1) at those coordinates. STACK: [1]
During the first run, the upper left corner changes from - (45) to , (44).
During the thirteenth and last run, the upper left corner changes from ! (33) to space (32), essentially cutting the wire.
270° Pop the stack. Since the popped element is 1, continue. STACK: []
315° Subtract. Nothing is done, since the stack is empty.
45° Push 1. STACK: [1]
45° Push 1. STACK: [1 1]
45° Push 1. STACK: [1 1 1]
135° Pop the stack. Since the popped element is 1, pop two more values (1 1) and push the code point of the character at those coordinates. STACK: [(n-1)]
45° Push 1. STACK: [(n-1) 1]
45° Push 1. STACK: [(n-1) 1 1]
135° Pop the stack. Since the popped element is 1, pop two more values (1 (n-1)) and push the code point of the character at those coordinates. STACK: [c]
During the first run, this retrieves the character at (44, 1), which is H.
45° Push 1.
225° Pop the stack. Since the popped element is 1, pop the next item and print it to STDOUT. STACK: []
180° Jump to the rightmost star on the first line.
135° Get/set. Nothing is done, since the stack is empty.
After this turn in the upper left corner, the particle starts over.

That is amazing.  I couldn't figure out how to exit the loop and settled for doing it the long way - big mistake.

Zsh, 17 bytes
<<<Hello,\ World!

Piet, 93 codels
The 1 pixel bitmap of the 31x3 program :

There might be still some room for improvement.
But the Direction Pointer & Codel Chooser are not making things easier.
This is the 12 codel image :

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

PietDev should be used with caution because it ignores some specs. The black start codel problem is one of them. The other is wrong behavior for the DIV operation that generates float values although the spec says that all values in Piet are integers. Npiet is a good way to check if a program really works.

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

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

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

-1 Language name makes me want cheese ;)

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!

Piet, 15x15(225) 13x15(195) codels
I think Piet program size is counted by codels. If someone wants to know the size in bytes anyway, I could shrink it down to 495 bytes(15x15 codels) and 476 bytes(13x15 codels) using PNGGauntlet.
Codel size 10 for better visibility.
13x15 version:

First version (15x15):

I was a bit lazy with this solution. I should be able to golf it down a bit more. This solution fills up the stack with ASCII-32 and reads it out in a loop (ASCII+32).
Output:
D:\codegolf\Piet\npiet-1.3a-win32>npiet "Hello World codegolf.png"
Hello, World!
D:\codegolf\Piet\npiet-1.3a-win32>

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.

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.

Here's an explanation... It's not great. I don't know the proper vernacular for this language. Try it online!

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

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 )

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

Nice job! I was hoping someone would beat the official HW example eventually. :)

I wonder if they misspelled "weird" intentionally...

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

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.

class P{static void Main(){System.Console.WriteLine("Hello, World!");}} -- 71 bytes. More golfing you must do young padawan.

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

The newline in the output is optional, so use Write instead of WriteLine to save 4 bytes

Yeah, a lang of Microsoft is worse than Java!

Fortran, 28 bytes
print'("Hello, World!")'
end

You can't write print*,"Hello, World!" because there's a leading space in the default print format. Thus, we pass in our own format that simply contains a constant string.

Which version of Fortran is this? In F77 you'd need some spacing if I'm not mistaken.

@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

Yes, F77 is fixed format, so you'd need some tabs, which adds to byte-count :(

GFortran: print*,"Hello, World!";end 26 bytes, but it prefixes a space char :(

Hexagony, 30 29 bytes
H;_e;r;2l.;P.QW;l/P1;@;0d;\o;

Try it online!
Source laid out:
    H ; _ e
   ; r ; 2 l
  . ; P . Q W
 ; l / P 1 ; @
  ; 0 d ; \ o
   ; . . . .
    . . . .

One more byte off!
Here's a crappy gif of the program in action.

Given there's 2 nops inside the program itself, I'm confidant this can be golfed by at least one more byte. I'm willing to offer a bounty for a smaller version.
Old version:
H;e;r;0Pld;P_1;l;;o;Q\;W\;$2@\

Try it online!
Source laid out:
    H ; e ;
   r ; 0 P l
  d ; P _ 1 ;
 l ; ; o ; Q \
  ; W \ ; $ 2
   @ \ . . .
    . . . .

Reuses the same tricks as Martin Ender's answer, i.e Q2 printed is the comma, P0 is the space, P1 is the bang, but manages to be 2 bytes shorter through clever mirroring to reuse several ;s and the o.
Explanation:
Here's a coloured Hexagony grid to show the non-branching path that the pointer takes:

The executing code, ignoring mirrors, is:
H;e;l;;o;Q2;P0;W;d$;o;$2r;0Pl;Wd;P1;@

Filtering out the skipped instructions and the literals that are overwritten by other literals, we are left with:
H;e;l;;o;Q2;P0;W;o;r;l;d;P1;@

Which simply prints "Hello, World!"
After a few attempts, I gave up on a size 3 Hexagony answer. You need a minimum of 12 instructions out of 19 reserved for string literals, along with three ;s for printing and one @ for ending the program. This leaves only 3 spaces for IP management and memory management, provided you find the optimal path that reuses both the o and the l. From all this, I'll rule that a size 3 answer is impossible, though I'll give a sizable bounty to anyone who proves me wrong.

I posted a shorter solution.

I 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 It's been a while, but I noticed you never posted your 25 byte solution. Do you still have it or remember it?

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

Trianguish, 187 bytes
00000000: 0a04 10c3 0201 40d9 1020 1403 a040 4d0e
00000010: 2060 4d11 040b 003c 050e 204d 0203 c027
00000020: 060c 5107 106c 1040 4d0e 2050 c310 2028
00000030: 03f0 6074 1104 10c3 0502 c04e 0203 c027
00000040: 0611 0710 c510 404d 0e20 50e0 1020 2803
00000050: a060 2f10 7107 7105 0e20 4d04 10c3 0203
00000060: c027 0710 2310 2028 03a0 404d 0e20 50c3
00000070: 1060 5d11 0203 c027 050e 204d 0410 c307
00000080: 1077 1040 4d0e 2020 2803 a050 c310 607a
00000090: 1105 0e20 4d02 03c0 2704 10c3 0710 7410
000000a0: 404d 0e20 2028 03f0 50c3 1060 6b11 0202
000000b0: 9105 0e20 4d07 1024 1050 c2

Try it online!

Trianguish is my newest language, a cellular automaton sort of thing which uses a triangular grid of "ops" (short for "operators"). It features self-modification, a default max int size of 216, and an interpreter which, in my opinion, is the coolest thing I've ever created (taking over forty hours and 2k SLOC so far).
This program consists of a central "spine" of wires and splitters, which transmits a 1-tick pulse of non-NIL data, and a number of "nodes" which print one character of the string as the pulse passes them.
At the start of the "spine" is a 1-tick pulse generator, one of the most basic, and important, applications of Trianguish's self-modification:

In this case, a 0 constant is used, as the actual number sent along doesn't matter, since it's used purely for timing.
Each "node" along the program consists of a T-switch, essentially a transistor, which permits an ASCII character code to flow through it for exactly one tick as the initial 1-tick pulse passes by. These character codes are produced by S-builders, which read the internal representation of an adjacent op, which in this case are tuned to match the correct characters. Only one node is different from the rest, that being the third, which instead of printing a single l splits the signal into two and prints both simultaneously. This also requires an additional delay for the next character.

Very good name. :)

BBC BASIC, 20 bytes
PRINT"Hello, World!"

Ahh, this was my first language :)

so BBC Basic does not accept ? as a shorhand for print?

@edc65 I have no idea... I'll try

@edc65 It doesn't work in BBC BASIC for Windows

Strange, as it's quite standard in basic. A posted an answer as VBA

Is the trailing quotation mark required?

@edc65, The "?" is NOT accepted, seems it conflicts with BBC Basic's PEEK() variant. But this is: P."Hello, World!"

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.

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.

Is Packed ASCII a programming language on its own right?

@user3819867 It's an edge case. It depends on definitions.

Packed 7-bit ASCII is the encoding SMS uses

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.

Javascript, 22 bytes
alert("Hello, World!")

You don't NEED semicolons in Javascipt!

Don't you need them?

Apparently not for 1 liners (I don't know JS golfably)

The JS interpreter will automatically insert them where it thinks they should be, if they aren't present

It does not print to stdout like the spec says

@ValentinLorentz Javascript doesn't have a stdout - I used the nearest alternate; see Default for Code Golf: Input/Output methods

PDP-11 (Unix) Assembly, 33 38 bytes
Source (No trailing newline required):
sys 4;10;15;sys 1;<Hello, World!>

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

The output is zero-padded to 60 bytes for some reason, but I know enough about the architecture to know that it doesn't matter and can be considered 38 (maybe 37) bytes. Unfortunately, while this works on the terminal, it actually prints to STDIN.
So, a correct program (I believe it exits with status 1, but that's not important) is:
5200;sys 4;12;15;sys 1;<Hello, World!>

That 5200 in the beginning is actually an "inc r0" instruction, but writing it in octal is shorter. Coincidentally, the length of this source code is also 38 bytes.
0000000 000407 000030 000000 000000 000000 000000 000000 000000
0000020 005200 104404 000012 000015 104401 062510 066154 026157
0000040 053440 071157 062154 000041 000000 000000 000000 000000

Output clocks in at 20 non-zero words, or 39 non-zero bytes, and this time the assembler doesn't insert quite as much padding so the actual output file size is 48 bytes.
Unobfuscated source for the same program:
inc r0
sys write; 0f; 13.
sys exit
0: <Hello, World!>

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

So is your answer optimized for short machine code, or for short source?  Or both?  Maybe post two header lines, one for the machine-code count and one for the asm source count?

gs2, 2 bytes
\x12h

where \x12 is a raw byte.

Sed, 14 bytes
I'm hoping the sed exemption from no-input-rules applies here.  If so, we can do:
cHello, World!

All that is required as input is one empty line.

cHello, World!

@MitchSchwartz excellent - I've never used the c sed command before - thanks!

Something like sed -e 'cHello, World!' <<<''

GNU Make, 27
$(info Hello, World!)
a:;@:

You can stick these two lines together, in either order, on one line to eliminate one more char.

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

+6 carrot.png

Write the version number as "^".

@ΚριτικσιΛίθος Sure! Done.

Version ^3 makes the ^ optional is you do not want to use any commands. Thus this can be shortened down by one byte.

@ΚριτικσιΛίθος Cool! Added that.

VSL, 35 33 bytes
Saved 2 bytes thanks to @ASCII-Only
fn main(){print("Hello, World!")}

Try it online!
Okay after over one year development, the day has come where I can post this :D
There is a print("Hello, World!") function but this is shorter. As  I seperate libc and libvsl this will probably have to switch over to print but for now this is the shortest.

Using fn can save two bytes

Foo, 14 bytes
"Hello, World!

Not printing Hello World seems to be a lot harder in Foo that the opposite...
Try it online!

Would s print Hello World? ;)

Probably.

If you find out, you might be able to golf it down to 0 or 1 byte!

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

This maybe could be golfed more if you allow the code to intersect itself.

I really don't understand why "1111" is a "W". The ascii code for 'W' is 87. Can somebody explain this to me?

Oh, I see the explanation in the description, but I wasn't aware that . did a % 256 before printing.

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
}

would int main be smaller, with ret 0 instead of ret void?  I don't know LLVM IR at all, really >.<

You can put a raw null byte instead of \00, do call i8@puts, and use [14x i8] to save space

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.

Ziim, 1222 bytes
In an unexpected turn of events, I'm counting this submission in UTF-16.
↘ ↓↘↘↘↘↙↓↘↘ ↙↓↘ ↓↘ ↙↘←↓ ↘↘↙↓↘↘↘↙↓↘↘↘↘↙↓↘↘↘↘↙↓ ↘↘↙↓↘↘↙↓↘ ↙ ↘ ↓↘ ↙↘←↓↘ ↙ ↘ ↓ ↘↘↙↓↘↘↙↓↘↘↘↘↙↓ ↘ ↙↘←↓↘ ↙ ↘ ↓ ↘ ↙ ↘ ↓↘↘↙↓↘↘↘↙↓↘↘↘↙↓↘↘ ↙↓↘←↓↘ ↙↓↘ ↓↘↘↙↓ ↘↘↙↓↘↘↙↓↘ ↙↘←↓↘ ↙↘←↓ ↘ ↙↘←↓ ↘↘↙↓↘↘↙↓ ↘ ↙ ↘ ↓↘↘ ↙ ↘ ↓↘ ↙↓↘←
↓→↘ ↑↑↓→↘ ↑↓  ↓→↘ ↓↓↓→↘↘ ↓→↘ ↑↓→↘ ↑↑↓→↘ ↑↑↓→↘↘ ↓→↘ ↓→↘ ↓↓↓↓→↘ ↓↓↓→↘ ↓↓↓↓→↘↘ ↓→↘ ↓→↘ ↑↑↓→↘↘ ↓↓↓→↘ ↓↓↓↓→↘↘ ↓↓↓↓→↘ ↓→↘ ↑↓→↘ ↑↓→↘ ↑↓  ↓→↘ ↓  ↓→↘ ↓→↘↘ ↓→↘ ↓→↘ ↓↓↓→↘ ↓↓↓→↘↘ ↓↓↓→↘↘ ↓→↘ ↓→↘↘ ↓↓↓↓→↘ ↑↓↓↓↓→↘ ↓  ↓→
↗  ↑↖ ↗  ↑↖↗↑↗↗  ↑↗↗↗  ↑↑↗  ↑↖↗  ↑↖ ↗  ↑↖ ↗  ↑↑↗  ↑↗  ↑↗↗↗↗  ↑↗↗↗  ↑↗↗↗↗  ↑↑↗  ↑↗  ↑↖ ↗  ↑↑↗↗↗  ↑↗↗↗↗  ↑↑↗↗↗↗  ↑↗  ↑↖↗  ↑ ↗  ↑↖↗↑↗↗  ↑↗↑↗↗  ↑↗  ↑↑↗  ↑↗  ↑↗↗↗  ↑↗↗↗  ↑↑↗↗↗  ↑↑↗  ↑↗  ↑↑↗↗↗↗  ↑↖↗↗↗↗  ↑↗↑↗↗

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

Click for larger version
Well, this is a bit embarrassing. I spent quite some time on this solution, and at 610 characters, it is 267 characters shorter than the one on the esolangs page. However, it contains a lot more arrows, and because those are 3 bytes in UTF-8, it's actually longer than the one on esolangs (1516 vs 1345). But because this solution is so dense and contains far more arrows than spaces, I'm actually saving bytes by using UTF-16 and counting each character as two bytes.
Anyway, regardless of how we're counting, this is far from optimal. The above code is entirely linear, and builds one bit at a time. So I'm not reusing any bitstrings (like I could for the ls or os or even other substrings). I chose this approach because I wanted to start with something where it would be easier to pack the arrows very densely. If one used a more square layout, one could make use of a lot more repetition in the output (on a bit level), and thereby make massive savings.

Most 2d languages are generally scored by the area of the bounding box, why not do that here?

@SuperJedi224 [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.

I've definitely seen befunge and <>< scored that way before, and that's how I've generally been scoring BotEngine.

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

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.

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"

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

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

This exits with INT 3 (breakpoint), so your shell may display a message to indicate this. However, the program itself prints nothing to STDERR.
Try it online!
Verification
$ cksum hw32
3205536342 59 hw32
$ ./hw32
Hello, World!Trace/breakpoint trap
$ ./hw32 | cat; echo
Hello, World!
$ ./hw32 | xxd -g 1
0000000: 48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21           Hello, World!

or echo $(./hw32)

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.

This is probably the first interesting use of a HW-built-in I've seen in this challenge.

قلب repl, 21 bytes
قول"Hello, world!"

Online repl
Qalb is a programming language designed for Arabic speakers as opossed to the anglophone stance of most popular programming languages.
I took this program from wikipedia and fiddled around with it, managing to save 3 bytes.  If you were wondering, قول means "say".
I haven't managed to get a full implementation running on my computer so for now I am just using the repl.

Ruby, 18 19 bytes
puts"Hello, World!"

Output wasn't quite right. Thanks Martin

Why not p"Hello, World!"? It's only 15 bytes.

@John: p always always prints quotes around strings.

R, 20 bytes
cat("Hello, World!")

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!

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.

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

This is... wait, wrong challenge.

80 bytes

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

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

You're cheating. Last I checked, COBOL needed a lot of newlines and useless spaces at the start of each line...

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.

@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

Self-modifying Brainfuck, 28 19 bytes
␀ represents a literal NUL byte.
<[.<]␀!dlroW ,olleH

Try it online
This is my Python interpreter that is referenced on the Esolangs page for SMBF. The default/example program is the program above. The SMBF code is entered on line 178 so that the Input box can be used for STDIN.
If input is not empty, it would need to be this (20 bytes):
<[.+<]␀!dlroW ,olleH

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

The second version could be just <[.+<]\x00!dlroW ,olleH, couldn't it?

@primo Yeah, it could.

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

Taking input when you're not supposed to isn't allowed. That's what the 2nd program is assuming.

Try it online!

@Deadcode Yes, but not easy to see what the code actually is in that interpreter. Also, that's technically a different implementation, because TIO's implementation won't execute dynamic code (code added after the end of the initial tape). Though that's not an issue for this challenge, it is for others.

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!

Ÿ™, That's right, I just trademarked Ÿ. You cannot use it without doubling your code golf score :P

@CᴏɴᴏʀO'Bʀɪᴇɴ Hahaha, fair enough then :p

ELF 64-bit LSB executable (Linux), 104 bytes
0000000: 7f 45 4c 46 02 01 01 03 b0 04 b3 01 b2 0e eb 18  .ELF............
0000010: 02 00 3e 00 01 00 00 00 08 00 40 00 00 00 00 00  ..>.......@.....
0000020: 30 00 00 00 00 00 00 00 b9 48 00 40 00 90 eb 30  0........H.@...0
0000030: 01 00 00 00 01 00 38 00 01 00 00 00 00 00 00 00  ......8.........
0000040: 01 00 40 00 00 00 00 00 48 65 6c 6c 6f 2c 20 57  ..@.....Hello, W
0000050: 6f 72 6c 64 21 0a 00 00 6f 72 6c 64 21 0a 00 00  orld!...orld!...
0000060: cd 80 b0 01 b3 00 cd 80                          ........

This sets as many proper headers as possible without affecting the byte count, prints a trailing linefeed and exits cleanly with exit code 0.
Try it online!
Verification
$ cksum hw64
3288151474 104 hw64
$ file hw64
hw64: ELF 64-bit LSB executable, x86-64, version 1, statically linked, corrupted section header size
$ ./hw64
Hello, World!
$ echo $?
0

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

O_o why is there an extra orld!

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

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.

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

Wish I could vote this up a second time; sweet golf!

Wish I could vote this up a second time; sweet golf!

Try It Online? (Charcodes only though)

Objective-Java*#++--.NETScriptnotation.sh, 22 bytes.
"Hello, World!".pdf.txt

Try it online!
How it works:
"Hello, World!".pdf     # Pushes "Hello, World!" to the stack.
                   .txt # Print the top item on the stack.

This is a stack-based esolang that I created that uses file extensions for commands.

Lua , 22 20 bytes
print"Hello, World!"

Try it online!
Thanks to @mathmandan for saving 2 bytes

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

How about ="Hello, World!" – because technically this does output "Hello, World!".

@Socialz I just relized(thanks to you) that the = is not even necessary.

@JakeBacker I can't reproduce that though, heh, which version are you running?

@Socialz http://repl.it/BGIS

@JakeBacker Cool! In that case this works as well [[Hello, World!]]. Yours is obviously shorter, though.

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!

+1 for completing the alphabet. Also for answering like 20 times.

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!

Trigger, 40 bytes
HHHeeelll#lllooo,,,   WWWooorrrlllddd!!!

Trigger is pattern-based, so commands are symbol independent. Three of the same character outputs that character to STDOUT.
The # is to introduce a break in the middle so that the double l doesn't turn into a six-long pattern, which will not decompose as intended. A single char is a NOT operation, but it is irrelevant for our purposes.

Can you only go 1 letter at a time? Or could you say Hello, World!Hello, World!Hello, World! which would be 1 character shorter because it doesn't need the "#"?

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

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.

Does it work if you omit content-length and just close the connection?

@jimmy23013, I didn't check it. I expect your version to work, but it won't be a valid response as I understand.

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.

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.

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.

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.

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.

Congratulations on posting the 300th answer to this question. [insert_celebrate_emoticon_here]

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.

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

What do the ';' do? A combination of . and ,?

@RikerW any non > or < character is treated as "add the currently pointed at character to the result"

Oh, okay.  That makes sense.

I hate you so much. So, so much. So much.

@QPaysTaxes Thanks mate :)

"readable version" Don't you mean "very slightly less unreadable"?

@AlexL. It's much more readable, what are you talking about? :P

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)

AArch64 machine language Linux, 48 45 37 bytes
00:   d2800020        mov     x0, #0x1  ; stdout is fd=1
04:   100000a1        adr     x1, 18    ; put addr of string to x1
08:   d28001a2        mov     x2, #0xd  ; length of string
0c:   d2800808        mov     x8, #0x40 ; select write() syscall
10:   d4000001        svc     #0x0      ; syscall
14:   d65f03c0        ret
18:   6c6c6548        "Hello, World!"
1c:   57202c6f
20:   646c726f
24:   00000021

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.
int main[]__attribute__((section(".text")))={0xd2800020,0x100000a1,0xd28001a2
,0xd2800808,0xd4000001,0xd65f03c0,'lleH','W ,o', 'dlro', '!'};

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

Got another byte with arithmetic: Try it online!

@ØrjanJohansen Oh wow, now it's getting crazy. :D

Very odd language..  And a good explanation of how it works, nice!

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

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 _

EBCDIC Punched Card, 13 bytes

Disk Operating System/360, also DOS/360, or simply DOS, is a
  discontinued operating system for IBM mainframes. It was announced by
  IBM on the last day of 1964, and it was first delivered in June
  1966.In its time, DOS/360 was the most widely used operating system in the world.
A typical configuration might consist of a S/360 model 30 with 32KB
  memory and the decimal instruction set, an IBM 2540 card reader/card
punch, an IBM 1403 printer, two or three IBM 2311 disks, two IBM 2415
  magnetic tape drives, and the 1052-7 console.

Generator: http://www.kloth.net/services/cardpunch.php
Scanner: https://www.masswerk.at/cardreader/

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

ARM (Thumb), 29 bytes
Assembly:
.section .text
.global _main
.thumb
_main:
    mov r7, #4         // 2704   syscall #4 (write)
    mov r0, #1         // 2001   fd #1 = stdout
    add r1, pc, #8     // a102   string address = (pc+4) + 8 (msg)
    mov r2, #13        // 220d   string length = 13
    svc #0             // df00   write(1, msg, 13)

    mov r7, #1         // 2701   syscall #1 (exit)
    mov r0, #0         // 2000   exit code 0
    svc #0             // df00   exit(0)

msg: .ascii "Hello, World!" // 13 bytes, without trailing newline

How to run this on Ubuntu:
sudo apt-get install qemu-user qemu-user-static build-essential gcc-arm-linux-gnueabihf binutils-arm-linux-gnueabihf binutils-arm-linux-gnueabihf-dbg
# build and run as Thumb executable
arm-linux-gnueabihf-as main.as -o main.o
arm-linux-gnueabihf-ld --thumb-entry=_main main.o -o main
qemu-arm -L /usr/arm-linux-gnueabihf ./main
# see disassembly and calculate machine code size
arm-linux-gnueabihf-objdump -d main

Most parts of the instructions and the code structure are from this guide. A full Thumb instruction set reference can be found in this pdf, but I couldn't find any easier-to-lookup reference.
25 bytes (exits by segfault)
.section .text
.global _main
.thumb
_main:
    mov r7, #4         // 2704   syscall #4 (write)
    mov r0, #1         // 2001   fd #1 = stdout
    add r1, pc, #4     // a102   string address = (pc+4) + 4 (msg)
    mov r2, #13        // 220d   string length = 13
    svc #0             // df00   syscall
    nop                // 46c0   for 4-byte alignment of msg

msg: .ascii "Hello, World!"

While it is possible to call puts and similar by dynamically linking to libc, I don't think it's fair to discount the glue code generated by the linker (single puts call adds 36 bytes as section .plt).

// TODO: fix, 51 bytes
//TODO:idea:"Hello, World!"TODO:this code is cursed

// TODO: fix is a joke language with commands that look like "TODO" comments in source code, created by RocketRace for JT's langjam.

// TODO: idea: "string" pushes a string literal
// TODO: this code is cursed outputs that string

The language isn't really designed for golfing, but a bit of fiddling with the syntax got this down to 51 bytes. Here is a more "idiomatic" example taken from the language's README:
use std::io::{stdout, Write};
// TODO: someone on the internet told me "Hello, world!" is a good idea
fn hello() {
    let chars = &[
        '\n', '!', 'd', 'l', 'r', 'o', 'w', ' ', ',', 'o', 'l', 'l', 'e', 'H'
    ];
    let mut out = stdout();
    // TODO: somehow fix this cursed code
    for c in chars.iter().rev() {
        let mut buf = vec![0; 4];
        c.encode_utf8(&mut buf).unwrap();
        out.write(&buf).unwrap();
    }
    out.flush.expect("unwrap");
}

(the language simply ignores everything except the TODOs)

Aussie++, 34 bytes
G'DAY MATE!
GIMME "Hello, World!";

Tested in commit 0a5de7e. You're supposed to end the program with CHEERS C***!, but as of that commit it isn't strictly necessary. The opening G'DAY MATE!, with trailing whitespace, is; anything before that statement is not executed.

+1 for introducing me to this amazing language

Prolog, 23 bytes
write('Hello, World!').

What did you use to define a string if you didn't use "?

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

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

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

J, 15 bytes
'Hello, World!'

No call to any write function needed.

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.

Pascal, 32 bytes
begin write('Hello, World!')end.

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!

Haskell, 26 bytes
main=putStr"Hello, World!"

Try it online!

Putting one of the many compilers you downloaded for PLQ to good use I see. ;)

Deadfish~, 1 byte
w

Hooray for built-ins.

MATL, 15 bytes
'Hello, World!'

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

Is it finished? Congratz! Looking forward to seeing it in use. I'll hopefully have the chance to check it out one day :-)

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

Binary-Encoded Golfical, 40+1 (-x flag)= 41 bytes
Can be transpiled back into the standard graphical version using the included Encoder utility, or run directly using the -x flag.
Hex dump:
01 90 01 00 48 18 00 65 18 00 6C 18 18 00 6F 18
00 2C 18 00 20 18 00 57 18 00 6F 18 00 72 18 00
6C 18 00 64 18 00 21 18

Original image:

Zoomed in by a factor of 16:

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

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

FREAKING 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?)

Java for golf, but there's STILL a freakin' semicolon!

@cat yeah, I know. Me and Conor are trying to figure out how to avoid having to use it.

@cat well, Glava 1.2+ supports semicolon insertion before closing curly brackets, so it fixes that problem

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

My only words are "O_o"

@Downgoat Then I have done my job.

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

Try it online! Check Debug to see the generated binary code.
I tried several less straightforward approaches – including a port of @primo's brainfuck answer – but they all turned out longer.
How it works
The binary file above has been generated by assembling the following SASM code.
add 72  ; Set cell 0 to 72.
put     ; Print 'H'.
fwd 1   ; Advance to cell 1.
add 101 ; Set cell 1 to 101.
put     ; Print 'e'.
add 7   ; Set cell 1 to 108.
put     ; Print 'l'.
put     ; Print 'l'.
add 3   ; Set cell 1 to 111.
put     ; Print 'o'.
fwd 1   ; Advance to cell 2.
add 44  ; Set cell 2 to 44.
put     ; Print ','.
sub 12  ; Set cell 2 to 32.
put     ; Print ' '.
rwd 2   ; Retrocede to cell 0.
add 15  ; Set cell 0 to 87.
put     ; Print 'W'.
fwd 1   ; Advance to cell 1.
put     ; Print 'o'.
add 3   ; Set cell 1 to 114.
put     ; Print 'r'.
sub 6   ; Set cell 1 to 108.
put     ; Print 'l'.
sub 8   ; Set cell 1 to 100.
put     ; Print 'd'.
fwd 1   ; Advance to cell 2.
add 1   ; Set cell 2 to 33.
put     ; Print '!'.

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

Because the arguments to add and sub are considerably smaller. Arguments are encoded in bijective binary, and each digit requires 3 bits.

Folders (pure), 195 folders

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

I'm not sure how it translates to bytes, but we can just count the number of folders:   (src)
$ ls -l -R . | grep -c ^d
195

$ ls -l -R . | grep :$
./New folder:
./New folder/New folder:
./New folder/New folder/New folder:
./New folder/New folder/New folder (2):
./New folder/New folder/New folder (3):
./New folder/New folder/New folder (4):
./New folder/New folder (2):
./New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder/New folder (2):
./New folder/New folder (2)/New folder/New folder (3):
./New folder/New folder (2)/New folder/New folder (4):
./New folder/New folder (2)/New folder/New folder (5):
./New folder/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (11):
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (12):
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9):
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2)/New folder (2):

Folders (concise), 2 folders + (5 + 13) bytes
./Setup
./Setup/Hello, World!

Welcome to PPCG! / Using inline code formatting can be quite hard to read, I edited the answer.

Does this include the comma? I don't see one in your concise version but I don't have a folders installation to check.

According to the original site, (and by the number of folders) it is with the comma. I fixed my concise example.

Easier way to count: find * -type f | wc -l (counts lines of output)

Right, It is shorter by one character... But I could use -lR

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

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

Grass, 463 446 bytes
It exits with a crash. Append vw to get a non-crashing version (448 bytes).
wWWWwWWWWwWWWWWwvwwWWwWWWwvWwWwwwwwWWWwWWWwWWWWWwvwWWwwwwwwwwwwwWWWwWWWWWwWWWWwvwWWwwwwwWWWWWWWWWWWWwWWWwvWwwwwwwwwwwwWWwwwwwwWWWWWWWWwWWWWWWWwwWWWWWWwwwwwwwvwWWWWWWWwwwwwwwwwWWWWWWWWWWWWWwWWWwvWwwwwwwwwwwwwwwwwwWWwwwwwwwwwwwwWWWWWWWWWWWWWWWWWwvwWwWwwwwwwwwWwwwwwwWwwwwwwWwwwwwwwWwwwwwwwWwwwwwwwwwwwwwwWWWWWWWWWWWWWWWWWWwvwwWWWWWWWWWWWWWWWWWWWWWWwWWWwwwvWWwWWWWWWWWWWWWWWWWWWWWWwwwwWWwwwwwwwwwWwwwwwwWwwwWwwwwwwwwwWWWWWWWWWWWWwWwwwwwwwwwwwwwwwwww

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

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

:| explanation pls

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

@ASCII-only Added the link to answer. Not sure it is actually better.

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)

C++ (gcc), 40 bytes
main(){__builtin_puts("Hello, World!");}

Try it online!
Using builtins are shorter since #include takes up a lot of bytes. I believe this solution is optimal.

"Optimal?" A bold claim. Ken Thompson: "Last year I taught at University of Sydney I gave that to my class, the shortest self-reproducing program in C, and I got a surprise. I didn't think there was a surprise there to be had. But, I got somebody who has the shortest one I've ever seen, which is a record breaker, by about four characters of what I had proved to myself was the shortest program, and they did it by a totally different mechanism which of course nullified the proof." https://www.princeton.edu/~hos/mike/transcripts/thompson.htm

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!

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.

This 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 you are, of course, right. I golfed it and included both the golfed and verbose versions. The verbose version is MUCH funnier to read :)

I don't disagree, but I've chosen to focus my energy on objective rule enforcement over reading funny answers.

@pppery yes, thank you for your objectivity :)

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

Risky, 64 bytes
\22+\222]+]2:+1+:++!:++2:+*+1+0+[-*-*+02]+]2{*+++**+}+0!:+*+1+0+:+*+1+!!:+++0+0+:+0+0+0!{*++1+0+]+]+]+]+]+]+]+]+]+]+]+]+]+]+]+]

Try it online!
This is a new language made by @Radvylf. My explanation wouldn't do it justice so heres the Docs.
Explanation:
Takes the various codepoints for various characters and links them together.
Redwolf also created a version of it which is a simpler "tree" layout, which also comes in at 64 bytes:
**}+1+1!0+:+0+1+0+:+0++!0+:+0+++0+:+!++!{**+0+{+!**+0+2!+**+0+}+0+:+!++!:+*+0+{+0+:+0++!0+0+0+:+!**+0+!20+0+0+]+0+0+0+]+0+0+0+]

Try it online!

Halfwit -A, 15 bytes
>JM?M;J*?f?*M[?JN;k+Jkk;$<5b

Try It Online!
Halfwit is an experimental golfing language that fits most commands in half a byte. It only uses lists and integers, so the -A flag allows it to output characters.
This approach is pretty simple. The bit between > and < is the compressed integer 1408073740711211456312062497. 5 is the constant 128, which actually takes up 1.5 bytes because reasons, then b decompresses the integer into base 128.
The naïve approach of using a character list comes out at 19.5 bytes:
>*{>N;>N:>N:>Nk>;{>{+>J;>Nk>f{>N:>N{>{*

Try It Online!
Each segment between > is a base-14 compressed integer.

Cubestack, 65 bytes
S R2 R R2 f2 r R r R r r R' L2 R B2 R2 u r r r L r R R2 f' R b S'

Try it online!
Cubestack is a (useless) stack-based esolang that only uses moves on a Rubiks Cube. See the repository on GitHub for more information.

Here's what the cube looks like after "executing" the program

In case you didn't see it, there's a visualisation of the cube's net at the very bottom of the online interpreter

Positionally, 394 bytes
/           > \

  -
>    "!dlrow!" v
        v      <

   v  \ \   ^

  1

   ~

  ^           /
  <   \

      $ >    ",olleH "    .       .       .       .       .       .       .   $   .   $   .   $   .   $   .   $   .       .    v
                                                                                ;<

   < >  \
      \

Try It Online!
This is so cursed. I don't really understand how it works, but it does.

Outgolfed

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.

TI-BASIC, 22 bytes
"Hello, World!

Note that the lowercase letters are 2 bytes each.

I don't think the initial : is really part of the program, so I think this has a score of 22.

@Ypnypn I'll take your word on it :)

The colon definitely counts! It's like the C/C++ semicolon, except prefix instead of postfix. If you didn't know, you can enter multiple expressions on a single line by seperating them with a colon. Even if not that, the post asked for a full program, so it has to be there anyways.

The lowercase letters can be entered on a TI-84.

@Itay123 I rolled back your changes because they were mostly incorrect. If you look at the edit history of this question, you will see that the original included a colon. However, most of the readers from 6 years ago preferred it to not be counted. Because of that and the question's age, I would prefer to not re-introduce the colon into the answer.

@Itay123 they can be enabled with an assembly program http://tibasicdev.wikidot.com/asmprgm

@TheNumberOne You know, that's a fair point. I shouldn't have been more hesitant towards editing. Do you think I should add a solution of my own or just accept this?

@Itay123 I don't really care if you add your own solution. It might be against the rules if it is identical though?

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

C++, 48 bytes
(must be compiled with g++)
puts is slightly more concise than std::cout, shaving 6 bytes off of the other c++ answer.
#include<cstdio>
main(){puts("Hello, World!");}

With g++, you can eliminate the space on line 1 and the int on line 2.

@Dennis, done. I think this is the shortest possible in C++.

This is not legal C++ code. The return type of main must be int and cannot be empty.

@Hubi but it does correctly compile and run if you use g++.

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

int puts(...); instead of #include<cstdio> makes it 3 bytes shorter. Or not...

In Obj-c you can use #import instead of #include, 1 shorter :D

@DJMcMayhem The fact, that compiler compiles something, does not mean, that it is correct. C++ does not support default int.

@Zereges This was discussed on [meta[(http://meta.codegolf.stackexchange.com/questions/5851/are-compiler-specific-submissions-allowed).

In this code yields two errors with g++ in Mac OS.

It's 47 bytes, not 48

Beatnik, 148 Bytes
It could probably be done better, but this is one of the first times I used a stack based language.
Beatnik determines commands and values based in the scrabble score for the words, but it (thankfully) doesn't check them against a dictionary.
K QQQQQQQG ZD XO K QQJA KD ZD XO K KG KD ZD ZD ZD XO XO K B KD ZD XO K QQQQF ZD ZD XO K QQQD XO K A Z KD XO ZD XO K B KD XO ZD XO K J Z XO K QQQB XO

Python interpreter can be found here
A breakdown of what I've done
K QQQQQQQG  # push 72         72
ZD          # duplicate       72 72
XO          # output H        72
K QQJA      # push 29         29 72
KD          # add             101
ZD          # duplicate       101 101
XO          # output e        101
K KG        # push 7          7 101
KD          # add             108
ZD          # duplicate       108 108
ZD          # duplicate       108 108 108
ZD          # duplicate       108 108 108 108
XO          # output l        108 108 108
XO          # output l        108 108
K B         # push 3          3 108 108
KD          # add             111 108
ZD          # duplicate       111 111 108
XO          # output o        111 108
K QQQQF     # push 44         44 111 108
ZD          # duplicate       44 44 111 108
ZD          # duplicate       44 44 44 111 108
XO          # output ,        44 44 111 108
K QQQD      # push 32         32 44 44 111 108
XO          # output <space>  44 44 111 108
K A         # push 1          1 44 44 111 108
Z           # subtract        43 44 111 108
KD          # add             87 111 108
XO          # output W        111 108
ZD          # duplicate       111 111 108
XO          # output o        111 108
K B         # push 3          3 111 108
KD          # add             114 108
XO          # output r        108
ZD          # duplicate       108 108
XO          # output l        108
K J         # push 8          8 108
Z           # subtract        100
XO          # output d
K QQQB      # push 33         33
XO          # output

Can you add Scrabble scores to the explanation?

The version using valid scrabble words is only 100 bytes longer.

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

nice work ... I thought it could be done better

608 bytes using (define f (lambda (a b) (char (- (* 6 19) (* a 13) b))))

604 bytes after golfing Leaky Nun's answer slightly

Mascarpone, 29 bytes
[!dlroW ,olleH]$.............

The esolangs page notes that

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

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

I know this is way late, but you can loop by having an operation call itself [!dlroW ,olleH]$[/.:!]v*:!

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

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.

Your Mom, 14 bytes
'Hello, World!

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

Brain-Flak, 180, 176, 170 + 3 = 173 bytes
((()()())((((((((({})){}{}){}){}){})(((()()()){}()){}){}())([])[]{})))((((([][]()){}){})[[][]])<>)<>((((((({}))[]{}[][]())[][][])()()())[[]]()()()())[[]]()()())(<>{}()<>)

Try it online!
This code is 170 bytes long, but adds three bytes for the -A flag, which is required to force brain-flak to input and output in ASCII. One little detail is that this also requires the -r flag, but it did not when I first wrote this answer, so I am not adding one byte for it.
I'd post a detailed explanation, but this language hurts my brain...
Thanks to @Wheatwizard for saving 4 10 bytes!

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

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

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

@WheatWizard Good tips, thankyou!

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

Ok, two more: try it online

Another two: try it online

V, 14 bytes
iHello, World!

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

Casio Basic, 15 Bytes
"Hello, World!"

I think it explaines itself well enough...

Hello, and welcome to PPCG! This is a good answer; the downvote was an automatic Community downvote (AFAIK), and I cancelled it with an upvote.

Thanks and sorry that I messed up the formatting, I'm not really used to yet...

Perfectly OK! Just use four spaces before code, and a pound sign (#) or two before your header.

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.

It's not complex, just insanely difficult :o

@HyperNeutrino It's rather complex. Wait for the explanation :P

you should change the title on this

Also that is not postfix

@DestructibleLemon oh duh

The output is incorrect: the w should be a W.

@Dennis Crud, just a minute...

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

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

Windows Portable Executable (PE), 1175 bytes
By using the following Assembly code instead of C code (which inevitable imports unecessary libraries and whatnot), we can cut down the executable size from 261591 bytes (compiled C answer) to a measily 1536 bytes.
extern ExitProcess, GetStdHandle, WriteConsoleA

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

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

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

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

However, that is still way too large. So I installed HxD, a hex editor, and went on to try and remove unecessary parts.
Apparently, Windows' executables are filled with padding (hex indication) for no apparent reason. So I removed the tailing block of zeroes at the end of the file, messed around a bit, and managed to cut it down to 1175 bytes. Here's the pastebin hexdump of the executable.
Unfortunately, at my every attempt to remove the other paddings (0x1A8-0x1FF, 0x22B-0x3FF), the program would simply not run. I've been doing this for a few days to no success. Thus, I'm posting this beaten, at the still staggering 1KB of size.
I am sure this can be golfed even further, so if anyone manages to cut down the size, feel free to edit this answer or perhaps even post another one.

As a bonus, this executable also works on DOS.

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

https://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.

Integral, 13 bytes
÷Hello, W╗ld!

Try it!
Sadly, Integral cannot yet compress capital letters, so it could not do much compression.
÷ means start compressed string.
Ignoring punctuation and capitalization yields
Integral, 9 bytes
÷▓llo═╗ld

Try it!
See also: Showcase

Can you put Integral on GitHub?

Also, how do loops work? I tried using e but it froze the interpreter.

@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

@petStorm I haven't used GitHub yet, but I am working on it.

@petStorm GitHub repository. For some reason the code is not working. For now keep using the old interpreter.

@nph Thanks a lot! (Because Google sites is inaccessible in my location)

@petStorm the GitHub html cannot render the symbols, so it is unusable. I don't know why.

@petStorm The js does work.

Anyway, I created a GitHub pages online interpreter.

@petStorm Thank you!

@petStorm Hi china person

@HighlyRadioactive Now I feel confident to put that in my location bar

@petStorm How to identify chinese 1. Can't access certain sites 2. Don't add spaces after puncuations.

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:::::::::
!----------
[]

Any reason you used that particular song?

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

Great job! I'm glad to see people using Length.

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

Try it online!
Program:
inr r0
rtr r0
rtr r0
rtr r0
inr r0
rtr r0
rtr r0
rtr r0

prt r0

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

prt r0

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

prt r0
prt r0

inr r0
inr r0
inr r0

prt r0

prt r1

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

prt r3

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

prt r2

prt r0

inr r0
inr r0
inr r0

prt r0

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

prt r2

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

prt r2

inr r3
prt r3

What is 10IPL?
10IPL, short for 10 Instruction Programming Language, is a simple compiled language I made for use in a computer I'm building in Minecraft. I made an online interpreter for it (with a few extra features), since I think it's a neat language.
How does this work?
This program doesn't have anything fancy, it just uses three of 10IPL's instructions (Increment, Rotate, and XOR) to put numbers in registers, then prints them.
10IPL has four general purpose registers, r0 to r3. It also has r4 (or rp0) and r5 (or rp1), which are intended to hold pointers. I use these as normal registers to save having to waste bytes clearing the ones I've already used, since this program never needs to access memory.

Windows Portable Executable 32 bit, 268 bytes
xxd:
00000000: 4d5a 0000 5045 0000 4c01 0100 0000 0000  MZ..PE..L.......
00000010: 0000 0000 0000 0000 7000 0301 0b01 0000  ........p.......
00000020: 0000 0000 0000 0000 0000 0000 b400 0000  ................
00000030: 0000 0000 0000 0000 0000 4000 0400 0000  ..........@.....
00000040: 0400 0000 0000 0000 0000 0000 0400 0000  ................
00000050: 0000 0000 0004 0000 0100 0000 0000 0000  ................
00000060: 0300 0000 0000 0000 0000 0000 0000 0000  ................
00000070: 0000 0000 0000 0000 0200 0000 0000 0000  ................
00000080: 0000 0000 e600 0000 0000 0000 2e74 6578  .............tex
00000090: 7400 0000 4600 0000 b400 0000 4600 0000  t...F.......F...
000000a0: b400 0000 0000 0000 0000 0000 0000 0000  ................
000000b0: 0000 0000 68c5 0040 00ff 15da 0040 00ff  ....h..@.....@..
000000c0: 15de 0040 0048 656c 6c6f 2c20 576f 726c  ...@.Hello, Worl
000000d0: 6421 0063 7274 646c 6c00 bb01 0080 6701  d!.crtdll.....g.
000000e0: 0080 0000 0000 0000 0000 0000 0000 0000  ................
000000f0: 0000 d300 0000 da00 0000 0000 0000 0000  ................
00000100: 0000 0000 0000 0000 0000 0000            ............

source:
; nasm

BITS 32
base equ 0x400000

;
; DOS header
;
; The only two fields that matter are e_magic and e_lfanew

mzhdr:
    dw "MZ"       ; DOS e_magic
    dw 0

;
; NT headers
;

    dd "PE"       ; PE signature

;
; NT file header
;

filehdr:
    dw 0x014C            ; Machine (Intel 386)
    dw 1                 ; NumberOfSections
    dd 0                 ; TimeDateStamp UNUSED
    dd 0                 ; PointerToSymbolTable UNUSED
    dd 0                 ; NumberOfSymbols UNUSED
    dw opthdrsize        ; SizeOfOptionalHeader
    dw 0x103             ; Characteristics

;
; NT optional header
;

opthdr:
    dw 0x10B                    ; Magic (PE32)
    db 0                        ; MajorLinkerVersion UNUSED
    db 0                        ; MinorLinkerVersion UNUSED
    dd 0                        ; SizeOfCode UNUSED
    dd 0                        ; SizeOfInitializedData UNUSED
    dd 0                        ; SizeOfUninitializedData UNUSED
    dd start                    ; AddressOfEntryPoint
    dd 0                        ; BaseOfCode UNUSED
    dd 0                        ; BaseOfData UNUSED
    dd base                     ; ImageBase
    dd 4        ; DOS e_lfanew  ; SectionAlignment
    dd 4                        ; FileAlignment
    dw 0                        ; MajorOperatingSystemVersion UNUSED
    dw 0                        ; MinorOperatingSystemVersion UNUSED
    dw 0                        ; MajorImageVersion UNUSED
    dw 0                        ; MinorImageVersion UNUSED
    dw 4                        ; MajorSubsystemVersion
    dw 0                        ; MinorSubsystemVersion UNUSED
    dd 0                        ; Win32VersionValue UNUSED
    dd 1024                     ; SizeOfImage
    dd 1                        ; SizeOfHeaders          nonzero for Windows XP
    dd 0                        ; CheckSum UNUSED
    dw 3                        ; Subsystem (Console)
    dw 0                        ; DllCharacteristics UNUSED
    dd 0                        ; SizeOfStackReserve
    dd 0                        ; SizeOfStackCommit
    dd 0                        ; SizeOfHeapReserve
    dd 0                        ; SizeOfHeapCommit UNUSED
    dd 0                        ; LoaderFlags UNUSED
    dd 2                        ; NumberOfRvaAndSizes    for Windows 10; UNUSED in Windows XP

;
; Data directories (part of optional header)
;
    dd 0, 0                     ; Export Table UNUSED
    dd idata, 0                 ; Import Table

opthdrsize equ $ - opthdr

;
; Code section header
;

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

;
; Code section data
;

align 4, db 0

code:

;
; Entry point
;

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

msg:
    db "Hello, World!",0

crt:
    db "crtdll",0

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

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

;
; Import table (array of IMAGE_IMPORT_DESCRIPTOR structures)
;

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

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

codesize equ $ - code

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

Previous PE answer: 1175 bytes.
This program was tested on Windows 10 2004 64-bit and Windows XP SP3.
The answer is based on this article, which creates the smallest PE file on Windows XP.
I took the smallest file that works on Windows 10 from tinype.zip, which is
tiny.296, and added imports using tiny.import.209.
Other useful articles: one two.
Quirks:
Windows 10:

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

Windows XP:

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

I think 268 = 4 + 264, where 4 is the minimal offset of NT headers from the start of the file
and 264 is the minimal distance between the start of NT headers and
end of file. 264 is probably sizeof(IMAGE_NT_HEADERS32)+16 or sizeof(IMAGE_NT_HEADERS64).
Because Windows 10 imposes hard limit on minimal PE size, there is no need to cram section header, code and imports
into NT headers.
Of the four CRT libraries that are available on both XP and 10 (crtdll.dll, msvcrt.dll, msvcrt20.dll, msvcrt40.dll), I use
crtdll.dll because it has a shorter name and has not been updated since 1995,
so (it feels like) it's safe to import by ordinals from it. There is no big problem to import by names, but then those names must
be inside headers, which is a bit messier.
The program sometimes hangs if puts is imported and ret is used to exit the program (this is true for both crtdll and msvcrt),
so I use exit.

文言 / wenyan‑lang, 55 bytes
吾有一言。曰「「Hello, World!」」。書之。

Try it Online! (Online interpreter/IDE, I don't think there's a way to share code directly but just copy and paste into the editor and press Run)
For the "Hello, World!" in Classical Chinese example wenyan-lang themselves give (60 bytes):
吾有一言。曰「「問天地好在。」」。書之。

Welcome to Code Golf! Nice first answer. Looks like the link in the header might go to the wrong place.

Welcome! 吾有一言曰"Hello, World!"書之 works for 36 bytes.

@Dingus True, punctuation is indeed optional in wenyan-lang.

@RedwolfPrograms Thanks, I fixed it!

Haifuckqueue, 59 39 bytes
good job to @emanresu A for being epic gamer (shaved off a stanza)
you can only make improvements of 20 bytes at a time because of the haiku 5 7 5 rules lol
{H}$1
{lo, W}
p{l}p
{e}$7
{orld!}
$5ooo

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

Try it online!

You probably want to add a timeout on the server - It's currently printing millions upon millions of A to STDOUT with no sign of stopping anytime soon.

Golfed off a stanza!

i can't seem to reproduce the million print thing but i think i added a working timeout now of 5 seconds

bruh hacks @emanresu

i guess you mean if you try to use the goto line number thing it will go forever

My point is that you didn't add a timeout, so the server crashed when I tried to run an infinite looping program.

C# 9+, 38 bytes
System.Console.Write("Hello, World!");

As of C# 9, the compiler directly supports top-level statements in a single file.
This means that the infamous boilerplate of class Program { static void Main(string[] args) {...} } will be inferred at compile-time, and the top-level statements in the file will be directly inserted into the Main method.
As a result of this, C# is now able to achieve a complete Hello World program in just 38 bytes!

Carbon, 62 bytes
package c api;fn Main()->i32{Print("Hello, World!");return 0;}

Try it Online!
Thanks to @Steffan for fixing this
Carbon is a new language by Google, supposed to be a successor to C++. Pretty boilerplatey language, even longer than Java.

This doens't work, Console.Print is invalid. You can remove import Console; and use Print instead of Console.Print.

You can test here: https://carbon.compiler-explorer.com/

PA-RISC 1.1 machine language on HP-UX 10.20, 53 48 bytes
00:  eb 20 00 20  bl 18,r25     # load address of string to %r25
04:  34 1a 00 02  ldi 1,r26     # branch delay slot, fd=1 to %r26
08:  00 00 00 48                # "Hello, World!"
0c:  65 6c 6c 6f
10:  2c 20 57 6f
14:  72 6c 64 21
18:  34 16 00 08  ldi 4,r22     # select write() syscall
1c:  20 20 08 01  ldil -40000000,r1
20:  e4 20 e0 08  ble 4(sr7,r1) # HP-UX syscall
24:  34 18 00 1a  ldi d,r24     # branch delay slot, length of string to %r24
28:  e8 1f 1f dd  b 1c          # goto 0x1c
2c:  34 16 00 02  ldi 1,r22     # branch delay slot, select exit() syscall

(UNTESTED) For Linux, you may have to change the syscall instruction to ble 0x100(%sr2, %r0) and may be able to remove ldil -40000000,r1
To try this on a PA-RISC machine or emulator, compile and run the following C program.
int f[]={0xeb200020,0x341a0002,'H','ello',', Wo','rld!',0x34160008,
         0x20200801,0xe420e008,0x3418001a,0xe81f1fdd,0x34160002};
int main(){
  ((int(*)())f)();
}

Brainfuck, 128 bytes
Generated using this generator, which is sub-optimal.
-[------->+<]>-.-[->+++++<]>++.+++++++..+++.[->+++++<]>+.------------.---[->+++<]>.-[--->+<]>---.+++.------.--------.-[--->+<]>.

Forth, 17 bytes
.( Hello, World!)

." Hello World! is one byte shorter.

." may only be used within a function declaration. ." : error(-14): use only during compilation

Why the space in .( Hello,?

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Forth requires spaces between tokens. The ending ) is the exception to the rule.

@mbomb007 It's unfair that ." is only in functions.

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Same with loops.

Batch File, 19 Bytes
@echo Hello, World!

Short and to the point. You'd think you could golf off the @ at the beginning, but if you do you get the literal program echo'd out before the string is printed. This is why you'll see @echo off at the beginning of near every .bat file around.
Example without the @
C:\Tools\Scripts>.\hello-world.bat

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

Isn't the language itself just called "Batch"?

@mbomb007 Kinda, sorta, maybe, not really. Batch files are just collections of lines that are executed by the associated command-line interpreter (usually COMMAND.COM but not necessarily, especially in newer Windows releases). It technically has some additional commands, like the infamous GOTO, but it's not in and of itself a language.

If you leave off the the echo you get an infinite amount of hello world!'s

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

@TimmyD It does that if i type directly into CMD but if it is run as a .bat it loops forever. Weird.

@User112638726 I believe it. Using batch files with command-line interpretation in Windows is ... quirky, shall we say. Nevermind the differences between CMD.EXE and COMMAND.COM, let alone the spaghetti code hodge-podge that's resulted in changes from DOS to 9x to NT to XP to Vista+ ... It's a right mess ... And that's not even counting the OS/2 flavors, the 4DOS flavors, DR-DOS ... or the ridiculousness of the FOR command ... ugh. Best to just leave all that crud behind and move on.

Well User112... gave me an idea. Rename your batch file to Hello.cmd and call it via Hello and you can shave off some extra bytes: @echo %0, World! 16 bytes

@MrPaulch if the filename is significant it has to be added to the byte coutn

Scala, 22 bytes
print("Hello, World!")

scala can run "scala scripts" which are not full program.
you can save the above to a file and execute in the shell scala file.scala, and it will execute (shortcut without saving a file: scala -e 'print("Hello, World!")').
a full ordinary scala program that prints hello world:
object H extends App{print("Hello, World!")}

Bash, 18 bytes
echo Hello, World!

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

Julia, 22 bytes
print("Hello, World!")

Short and sweet.

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

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.

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.

I got rid of my old version.

Please change the language name to "Inform 7 + C by G", since you're using a library

@ASCII-only As the cost of the library is included I don't think that's necessary.

@curiousdannii nope, it's still necessary (at least for libraries that don't come with the standard distribution)

Var'aQ, 20 bytes
"Hello, World!" cha'

Var'aQ nIv rur Hol. 'oH rut lo' jIH ngaj-ghItlh.
Note: ghu'vam laH mugh jIH vaj DaneH'a'.

mughwI' vItu' 'oHbe' majQa'.

@mbomb007 Qo', jIHvaD pIch, bing pIch

What language is this?

@LegionMammal978 Klingon :)

Quipu, 38 bytes
' 'H[]
'W'e/\
'o'l
'r'l
'l'o
'd',
'!/\

Try it online! Thanks to @user for getting the interpreter working on TIO.
By splitting the string in half across a couple of threads, you can get 3 bytes shorter than the trivial implementation of simply pushing the string and printing.

goruby, 6 bytes
h:H,:W

Apart from the method_missing override, goruby also defines Kernel#h which accepts 3 parameters: the first letter of _ello (default H), the first letter of _orld (default w), and the final character (default !).

Nice, I didn't know about the parameters it takes :)

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

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

You can omit return if you invoke the class with java -noverify. This causes the JVM to segfault after printing "Hello, Word!". (-7 bytes)
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)

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.

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.

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.

Candy, 18 bytes + 1 = 19 bytes
Push (technically queue) string (character-by-character) onto the stack, and loop to print
"Hello, World!"(;)

The interpreter should be called with -q to suppress STDOUT messages.

Why 3 bytes for switch? The Binary-encoded Golfical answer takes a switch and that's only a byte...

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.

The convention is typically 1 byte / switch. However, you can raise the question on Meta and get the community's opinion.

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

Wise, 135 + 3 = 138 bytes
~-<<<~-<<<::^~-<~-<<<~-<<~-:::^~-<<<~-^::?:>~-<~-:?::^~-<<~-<~-<<::^~-<<<<<:<::^<~-<<~-<~-<~-|!::^~-<~-<~-<<<~-<!:::^~-<<<^::^~-<<<<<~-

Try it online!

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.

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

Nice! I'm surprised anyone actually cares about this.

damn, that's a lot of trees cut down...

@Flp.Tkc Maybe I should make a version where you plant trees?

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 "

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.

@Tealpelican That works?

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.

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

You know you've attained master rank when you don't know why your code golf works, but it still does.

Of course. The true&tested method of "Can't possibly work, let's try it anyway." ~ Eugene van der Pijll

No, 1185 bytes
NOOOOOOOOOOOOOOO?Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooo
NOOOOOOOO?yes

Try it online!
No is a line based language, meaning that execution starts on the last line and the other lines are referenced throughout the program. Each line consists of the following:

A command, in the format of N followed by a number of Os. The number of Os determines which command is meant
One or more arguments, separated from the command with a ? and from each other with a !. The arguments can be one of four options:

N followed by \$n\$ os. This represents a character with charcode \$n\$
n followed by \$n\$ os. This represents an integer \$n\$
\$m\$ ns followed by \$n\$ .s and \$p\$ Os. This represents a floating point number with integer part \$m\$ and a fraction part consisting of \$n\$ \$0\$s followed by \$p\$. For example, nnn.O is \$3.01\$
ye followed by \$n\$ ss. This references the result found by running line \$n\$, 1-indexed.

This Hello, World program works by first running the last line:
NOOOOOOOO?yes

8 Os means that this is the output command, so this line outputs the value of line 1, the super long one. Line 1 works by using the „string builder“ command (NOOOOOOOOOOOOOOO or 15 Os) which takes a list of characters and returns them joined as a string. In this case, the characters form the String Hello, World! and so use the charcodes of those letters in order to return characters according to the 1st type of argument as specified above.

"Don't ask. Just read the GitHub page." I can't, it's a 404. There's not even an archive. So I ask: WHAT?!?

@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

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

@FabianRöling Yeah sure, I‘ll edit in an explanation now

The program sounds like a person being outgolfed.

@cairdcoinheringaahing More like, "Thanks for letting me no!"

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.

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

Golfed 16+1=17 for -l flag

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

Someone upvoted this, wow.

you should make a codepage for this.

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.

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:

http://web.archive.org/web/20060202003431/http://www.winterbergs.de/software/zte.htm

It has a link to is an interpreter at:

http://web.archive.org/web/20051222231734/http://www.winterbergs.de:80/software/ztinte.php

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:

http://web.archive.org/web/20060202003431/http://www.winterbergs.de/software/ExtractZT.exe

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

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

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.

Welcome to PPCG!

Pain-Flak, 152 bytes
)))))}{}{)))}{))(}{((((])][][][([(])()()([((]][[()()()(])}{][][)][(][([())(]][][][][][[))(]][[)][][)][][][][))(}{}{))))(}{)}{)}{))()()()((((((((((((}><{

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

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

For the Pain-Flak program in this answer, transpilation yields the following Brain-Flak program.
((((({}{}((({}((){}))))[([][][])])[()()()]))[[]])()()()[({}[][]([])[])])(()[[][][][][]](()[[]]([][]([][][][]((){}{}((((){}({}({}(()()()())))))))))))
{<>}
{<>}
(((((((((((()()()()){}){}){}()))){}{}())[][][][])[][])[[]]())[[][][][][]]())([([]([])[][]{})]()()()([[]](([()()()]([([][][])](((({}()){}))){}{})))))

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

Line 1 pushes garbage on the first stack.

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

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

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

You care if i use the pain-flak description for my readme?

@Christopher2EZ4RTZ Go ahead. :)

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.

I'm not going to let a computer beat me

@WheatWizard Really? :>

I will not.

Logo (programming language) - 20 bytes
PRINT [Hello, World!]

Or even more exciting version:
to helloworld
 hideturtle
 fd 20 left 180
 fd 40 left 180
 fd 20 right 90
 fd 20 left 90
 fd 20 left 180
 fd 40 left 90
 fd 20 left 90
 fd 20 right 90
 fd 20 right 90
 fd 10 right 90
 fd 20 left 90
 fd 10 left 90
 fd 30 left 90
 fd 40 left 180
 fd 40 left 90
 fd 20 left 90
 fd 40 left 180
 fd 40 left 90
 fd 40 left 90
 fd 20 left 90
 fd 20 left 90
 fd 20 left 90
 fd 60 left 90
 fd 40 left 180
 fd 40 left 90
 fd 20 left 90
 fd 20 left 180
 fd 20 left 90
 fd 20 left 90
 fd 40 left 180
 fd 40 left 90
 fd 40 left 90
 fd 20 left 90
 fd 20 left 90
 fd 20 left 90
 fd 40 left 90
 fd 20 right 90
 fd 20 right 90
 fd 5  left 90
 fd 5  left 90
 fd 25 left 180
 fd 40 left 90
 fd 40 left 90
 fd 20 left 90
 fd 20 left 90
 fd 20 left 90
 fd 20 left 90
 fd 40 left 180
 fd 40
end

lt 90 pu fd 200 pd rt 90 helloworld

Output:

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

First-timer here. Cool, thanks.

Hmm. I think you should stop drawing in between letters

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!

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

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

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!

46 bytes

@JoKing Nice! Very clever usage of the !. I hadn't thought of the use of _ as another way to discard the result of ,.

@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?

All I could get was a different 45er

Going back to my old version, I got 42 bytes (i swear, the last character being printed was completely accidental)

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

Technically, if you use the -i flag to disregard invalid instructions you can save one byte by removing the #

whenyouaccidentallylose100endorsementsinnationstates -  900   761   728   552  260 bytes
20280782166
114
fff#dff#dfffff#dfffffffffff#dfffffffffffffff#dffffffffffffffffffffffffffffffffff#dfffffffff#dfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff#dffffffffffffffffffffffffff#dfffffffffffffffffff#dffff#dffffffffff#dfffffffffff#d

Try it online!
Golfed down to 761 bytes by increasing the brute-forcer to seeds up to 9999, instead of 999
Golfed down to 728 bytes by increasing the brute-forcer to seeds up to 99999, instead of 9999
Golfed down to 552 bytes by increasing the brute-forcer to seeds up to 999999, instead of 99999
Golfed down to 260 bytes with the help of @ASCII_only

I'm very curious as to what the inspiration for this languages name is.

@GabrielMills Explained here to Dennis

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.

vJASS (Warcraft 3), 78 58 bytes
Using //! import zinc "<code_path>" command to exclude //! zinc and //! endzinc.
library a{function onInit(){BJDebugMsg("Hello, World!");}}

Explanation:

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

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!

CLC-INTERCAL, 221 bytes.
DO;1<-#13DO;1SUB#1<-#29DO;1SUB#2<-#1100DO;1SUB#3<-#249DO;1SUB#4<-#255DO;1SUB#5<-#250DO;1SUB#6<-#677DO;1SUB#7<-#373DO;1SUB#8<-#4160DO;1SUB#9<-#570DO;1SUB#10<-#2572DO;1SUB#11<-#225DO;1SUB#12<-#247DO;1SUB#13<-#348DOREADOUT;1

How I generated the code above.
There is other "Hello, World!" program that uses a tail array, but it has 278 bytes when I do these:

Remove GIVE UP statement
Replace PLEASE with DO, as politeness doesn't matter in CLC-INTERCAL
Remove every space and LF.

I think this is the only site that you can try CLC-INTERCAL online.
Edit. As of 1.-94.-2, politeness is not checked, unlike INTERCAL-72 and CLC-INTERCAL.

RickRoll-Lang, 70 59 bytes
no interpreter on tio so i cloned the repo on replit lol
takemetourheart
ijustwannatelluhowimfeeling "Hello, World!"

Explanation:
RickRoll-Lang keywords do not need spaces between them
takemetourheart                             -- "main()" function declaration
ijustwannatelluhowimfeeling "Hello, World!" -- print the string "Hello, World!"
                                            -- implicit "say goodbye" (end block) at the end

Try it online!

FIM++, 87 bytes
I golfed off one byte: the original was by @martinender.
I golfed off a space between a token said and a symbol ".
Dear Princess Celestia:A.Today I learned:I said"Hello, World!".Your faithful student,B.

Try it online!

tinylisp 2, 16 bytes
(w"Hello, World!

The write builtin, given a string, outputs its contents to stdout. Its short alias is w.
Just "Hello, World! would work except it outputs "Hello, World!" with quotes.

Actionscript 3.0, 23 22 bytes
trace("Hello, World!")

Does actionscript 3.0 REQUIRE semi-colons? I stopped after 2.0 but I don't think it did back then.

@AlbertRenshaw is correct, it doesn't require a semi-colon in 3.0.

This works in the Actions pane of the Flash IDE, but Flash Builder or the Actionscript compiler, you need a full class definition.

unc, 38 bytes
ZNVa[]<<chgf[L'uRYYb~ JbeYQ#']:if 5:>>

T-SQL, 20 bytes
print'Hello, World!'

Try it online

Nim, 20 19 bytes
echo"Hello, World!"

Saved one byte thanks to sp3000!

You can drop the space in between for the first one, I think :)

Indeed, saved me one byte!

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

Applescript, 15 bytes
"Hello, World!"

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

It's nice to see these verbose languages -- Applescript, PHP, PowerShell, etc. -- getting the better of lots of other languages for once. :)

@TimmyD That doesn't mean that they are good languages. It's just that they are better at some things.

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

I understand @TimmyD

Emily, 22 bytes
println"Hello, World!"

This is a nice little language I stumbled upon recently.

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.

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.

I always smile when I see this language.

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

I love reading the "Code" in a manner as if two people were talking to each other :)

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

///, 13
Hello, World!

can't get much simpler than this

Vim, 17 bytes
iHello, World!{ESC}ZZ

Where {ESC} is a raw escape byte \x1b.
This will switch to insert mode (i), write Hello, World!, leave it (ESC), and save+quit (ZZ). An environment like vimgolf or anarchy golf has to do the output part for you, as Vim is, of course, just a text editor.

@LegionMammal978 the other seems to be Vimscript mislabelled as Vim.

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

Way longer and wrong output, but more interesting: :h_4<CR>/"H<CR>ly2wZZp

Octave, 19 bytes
disp"Hello, World!"

Go, 64 61 bytes
3 bytes thanks to George Gibson
package main
import."fmt"
func main(){Print("Hello, World!")}

Go requires an import to print to standard output, unfortunately. No trailing newline.

package main;fund main(){print("Hello, world!")}

@eric_lagergren That prints to STDERR, not STDOUT. See here

Oh gotcha. Never looked it up because I never use it. Thanks.

Save 3 bytes by importing fmt into the global namespace with import."fmt" then just call Print("Hello, World!").

@GeorgeGibson Thanks, that's a nice trick.

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

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

PARI/GP, 22 bytes
print("Hello, World!")

3var, 65 bytes
iiisa-<*>P/>is+iP>PPm-iiiPi<O/<m/>+<O+d<+<O+><kkkOP->siskkkOP</>P

Here's a 3var program found by brute force. Note that this might not be optimal since I assume that we'll only ever need numbers in the range 0-150, for efficiency reasons. I'll probably address this in a later edit.
3var is a Deadfish variant which has, well, three variables A, B and R. The relevant commands are:
Command              A           B           other
-----------------------------------------------------------
Increment            i           a
Decrement            d           k
Square               s           m
Output as char       P           O
Copy from R          >           <
Set R = A+B                                  +
Set R = A-B                                  -
Set R = A*B                                  *
Set R = A div B                              /

And here's a trace:
Line           A     B     R     Output
----------------------------------------------------------------
iiisa-         9     1     8
<*             9     8     72
>P             72    8     72    H
/>             9     8     72    H
is+            100   8     108   H
iP             101   8     108   He
>PP            108   8     108   Hell
m-             108   64    44    Hell
iiiP           111   64    44    Hello
i<O            112   44    44    Hello,
/<m            112   4     2     Hello,
/>             28    4     28    Hello,
+<O            28    32    32    Hello,
+d<            27    60    60    Hello,
+<O            27    87    87    Hello, W
+><            114   114   114   Hello, W
kkkOP          114   111   114   Hello, Wor
->             3     111   3     Hello, Wor
siskkkOP       100   108   3     Hello, World
</             100   3     33    Hello, World
>P             33    3     33    Hello, World!

@LegionMammal978 Do you mean esolang wiki? The site seems fine to me...

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.

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.

Dogescript, 42 37  bytes
plz console.loge with "Hello, World!"

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

plz console.loge with "Hello, World!"is shorter, but admittedly less wow

Is the plz necessary? I thought you could just console.loge.

@AlexA. doesn't work without plz in the online interpreter, in accordance with the specs

That's what I was thinking...

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!

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 '''''>\++++++++)`

Using constants like that (assuming I got it right) reduces it to 136.  Probably better ways to do this still. '''''>``++++++++)@'''''''>``++++)+@''>``++)+@@+++@L''''''>``----)@''>``----)@''''''>``-----)@'''>``++++++++)@+++@------@''>``---)@L''''''>``+++)@

@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?

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

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.

The H is, in fact, not neccessary.

@Pavel You are correct. I removed the error for the beam leaving the source code when I ported it to TIO. Thanks :-)

Small optimised version. 159 bytes, changes the ending to use 2 less -. Try it online!

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!

@Tealpelican See also MickyT's 120 byte answer

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!

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.

Piet, 132 codels
On a 4x33 grid. On the last few commands I had to stretch to reach the end, meaning it could be golfed a little more (it probably fits on a 4x31 grid).
Here it is, with codel size 10:

I made it in a rectangular space to minimize the number of time I needed to flip the pointer. The stack is based on numbers 36 and 108 that are constantly being duplicated or rolled to produce the new letters.
Made and tested on PietDev.

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.

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.

Another solution would be S"Hello, World!".

@LegionMammal978 Indeed :) (although you'll need a ; at the end or it'll print forever)

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.

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)

TeaScript, 12 bytes
(using ISO/IEC 8859 character encoding)
D`HÁM, Wld!

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

This is 12 bytes, I think; there should be an unprintable in Wl.

@ETHproductions you're right, whoops. I guess SE kills unprintables

Perhaps a hexdump would be useful (via xxd or similar).

Acc!!, 122 bytes
Due to limitations of the scoreboard snippet, the title of this post is incorrect. The correct name of this language is Acc!! with italics.
108
Write 72
Write 101
Write _
Write _
Write 111
Write 44
Write 32
Write 87
Write 111
Write 114
Write _
Write 100
Write 33

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

@quartata Thanks for the edit, but italics in the language name breaks the scoreboard.

Ah. Sorry, didn't realize :P

Maybe the scoreboard snippet should be updated.

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.

BTClang, 53 bytes
My newest invention! BTClang is short for Bitcoin language. Although it has nothing to do with bitcoins, it shares some similiarities with this language. Code:
4|$&2h
2|A%
3|Im!
3|%([F
2|!4P
2|"Cv
3|zJO
1|!M
2|!&r

Explanation:
First of all, each line of the code consists of a number, a pipe and a key. The process goes as following for the example 2|5C. We take the key (5C), and generate the SHA256-hash of it. We get this:
ad5d3cc03d8b60e308b22e27fe4bbccae6a83d5496bc5e2a36aeb76eae51aeb0

The number before the pipe says how many hexadecimal number we want to extract from the end of the hash. This number is 2, so we take two 2-digit hexadecimal numbers from the end of the hash.
We are left with ae and b0. Converting these to integers will result into 174 and 176. These will be processed with the formula n % 94 + 32, so when this is converted to a character, the character will always be a printable ASCII character with 31 < ord < 128. The hashtags are replaced with newlines.
174 % 94 + 32 = 112 (p)
176 % 94 + 32 = 114 (r)

And so on...
The final translation of the code is print("Hello, World!"), which is then evaluated as normal Python. Although this is a solution, I am pretty sure this can be golfed further. It just takes a lot of computational power...
(By the way, you can try to find sets of characters yourself with the BTClang_miner)

How do you choose which hexadecimal numbers?

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

Oh, I'm an idiot. :|

Scratch, 15 bytes

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

You already welcomed me in Output the Current Time

Sorry, the review link said you were new.

Is this different from https://codegolf.stackexchange.com/a/76182/6691 ?

Well, this is awkward.

Emojicode, 37 bytes
Hello, World!

Golfuck, 39 bytes
jrseeqzjzzzsvDsj*aaa*r"s*hB(FsxahB(z*sh

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

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!

Wow, this is a great language. Nice work!

Seeing that 108, 111 and 114 are part of the output, maybe an alias to add 3 might help?

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

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

@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 Please publish it too, I wrote a longer program for the same thing before I discovered you had answered.

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!

*><>, 21 bytes
"!dlrow ,olleH"Ool?u;

Try it out on the online interpreter here.
*><> (pronounced "Starfish") is an esolang based on ><>, developed by redstarcoder. Its aim is to add some useful features which are missing from base ><>, such as file IO, time functionality, and an interesting feature called 'dive/rise', which is used here.
If the 'dive' command, u is encountered, no instructions other than directional modifiers are executed until a 'rise' command, O, is encountered. Encountering a dive whilst already diving, or a rise when not diving, is treated as a no-op.
"!dlrow ,olleH"Ool?u;

"!dlrow ,olleH"         Push "Hello, world!" to the stack in reverse.
               O        Rise - a no-op on first iteration
                o       Output top of stack as ASCII character
                 l?u    If length of stack is non-zero, dive
                    ;   End program execution

I love ><> and been interested in *><> so using the dive command for a huge benefit which I haven't seen before is great :)

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

Klein, 50 + 6 = 56 bytes
+3 bytes due to the -A flag.
+3 bytes for 000 topology (though in my testing, pretty much all valid topoligies work)
89*45:**:(1+:7+::3+:(492+*84*9:*6+):3+6:3**)84*1+@

(Eligible for the bounty)
Probably not optimal, but it's a start.

You do have to add 3 for the topology you are using and 3 for the -A flag, (but so does everyone else, so it shouldn't hurt you)

@WheatWizard Yep, just added that in.

https://tio.run/##DcgxDoAgEATA78BuTA45EbbSx1gYjf/vTqac573uL6IP@CZAqVA7pUolHyvRHUNozLOaKpDnFB4RsZxhZj8

@WheatWizard It appears to work with an empty argument as well. https://tio.run/##DcgxEoAgEAPA70AyFsiJkEofY@Ho@P8usuU@73V/dh@ITYBSoXZKlUoxVqIHhtCYZzVVIM8pPGwvp38

@Dennis Would that be +2 bytes then?

Could you make the title Klein, 50 + 6 = 56 bytes as it kinda messes up the catalogue?

@RandomUser Sure thing.

Klein, 48 + 3 + 3 = 54 bytes
89*55+:*:(1+:7+:::(3+:(485*+48*699*+):3+))148*+@

Try it online!

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.

Welcome to the site!

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

So I am. I shall fix this.

You can save 10 bytes: PROGRAM-ID.H.PROCEDURE DIVISION.DISPLAY'Hello, World!'.

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

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.

Seems like a very interesting language, but very verbose. Wow!

Is there a character I am missing? It shows up as 307/899 bytes for me, respectively

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

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

@programmer5000 -- According to the rules of this challenge, "The program must not write anything to STDERR."

Sqirrel - Peter, 903 bytes
A couple notes about my golfing:

The examples have punctuation at the end of sentences but the spec doesn't say that it should be there so I left it off.
The spec says The request consists firstly of the text "I wish I had a " then is followed by a thing. and list of the variable-things you can use: ... an Apple which is inconsistent so I used "I wish I had a Apple" because it is shorter.
The spec says Here is [nr] [thing][s]  Set the var to NR. Add an 's' if needed and even though the examples use Fishes the only ones that should be valid are Fish and Fishs and I chose Fish because I don't think it needs to be plural and it is shorter.
There is an exit command but the spec doesn't say what happens if the flow reaches the end of the text so I am assuming the program ends and I didn't use the exit command.

Here is my attempt:
I wish I had a Fish
Here is 72 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 101 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Apple
Here is 108 Apples
I wish I had a Apple
Now everyone has it
I wish I had a Apple
Now everyone has it
I wish I had a Forrest
Here is 111 Forrests
I wish I had a Forrest
Now everyone has it
I wish I had a Fish
Here is 44 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 32 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 87 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Forrest
Now everyone has it
I wish I had a Fish
Here is 114 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Apple
Now everyone has it
I wish I had a Fish
Here is 100 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 33 Fish
I wish I had a Fish
Now everyone has it

If I count correctly, that's 66 more bytes for the version with correct punctuation and grammar. I.e. an apple, 100 fishes, etc. and a dot at the end of each line.

Numberwang, 77 bytes
69696969696969693696969623673363316969696968359533059595636969663633563583193

Try it online!
Just incrementing and decrementing the pointer by certain amounts.

Brainfuck translation, 72

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.

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!

78 bytes

68 bytes

40% shorter now. Thank you!

golfed another two bytes off :P

Looks weird, but it works. Thanks!

65. looks even weirder >_>

@ASCII-only Thanks again!

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.

Welcome to PPCG!

AlphaBeta, 68 bytes
kjjjggDLeaCLcbbbCLLaaaCLjjjggDLjhhDLsFihhDLCLaaaCLdaaaaCLdaaCLsFiiDL

Try it online!

Atari Logo, 21 bytes
Code:
PRINT [HELLO, WORLD!]

Result:

]=[, 164 bytes
[=======[==]]=[[=[[=]]=[[=[[========]]][]=[]=[[=[=[=]]][]=[[====[====]]=[[===[==]]=[[========[=======]]=[]=[[=[=[====]]=[[=[[========]]=[[=[[]]=[[===[===]]=[[=[]]=[

]=[ was a language which only uses the symbols ], =, and [.
The ]=[ interpreter is written in 12-Basic.

There's something amusing about the fact that the ]=[ interpreter at the link is written in the 12-basic interpreter.

Permalink no longer works

now I can't find the interpreter...

I was looking through some old files and I found the interpreter, finally.

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

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.

I think this can be golfed more using multiplication.

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

Can you assume that regs like cx are already cleared?

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

 , 21 bytes
("Hello, World!")

Try it online!
This is a language written in Cuneiform, and uses Sumerian words as keywords.
At its heart, this is just a translation of Python into Sumerian, but in the future there will be new features added, such as the Babylonian numeral system (which works in base 60).
Because it relies heavily on unicode, this is not going to be a very good golfing language.

You could always translate from unicode to a golfier encoding :P

Grocery List, 98 79 bytes
H

w
nnn
d
c
c
z
f
v
d
v
l
v
r
v
o
v
W
n
b
s
v
X
nn
d
v
o
v
l
c
v
e
v
H
l
p
e
t

Save in a file then use this Python interpreter to run the specified program.

Could you please link to the interpreter you used to test this?

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.

fixed, but space can't print

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.

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.

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

EDIT: To try this on Linux (for SPARC), change the argument of the trap instruction to 16 for 32 bit mode and 109 for 64 bit mode.

Triangular, 55 bytes
6\6+@*8\C::6--::@\@#2"+3^82*@3/#-<*#+/@"#+F<3/3@@#-7:*<

This one took a while. Also will be very difficult to golf, since there is zero no-ops in it, meaning you'll have to save 10 bytes to get it to a size 9 triangle in order to save any bytes
This expands out into this size 10 triangle:
         6
        \ 6
       + @ *
      8 \ C :
     : 6 - - :
    : @ \ @ # 2
   " + 3 ^ 8 2 *
  @ 3 / # - < * #
 + / @ " # + F < 3
/ 3 @ @ # - 7 : * <

How it works
Note: this ignores all control flow characters and just looks at what gets run in order
66* Push 36
:: Duplicate it twice
2*# Output H, popping it
3*  Multiplies by 3, yielding 108
:   Duplicates
-7# Outputs e, popping it
@@  Outputs l twice, without popping it
3+@ Outputs o, without popping it
" Swaps, putting 36 at the top of the stack
:: Duplicates it twice
8+@  Outputs comma, without popping
C-#  Outputs space, popping the top of the stack
2*F+# Outputs W, popping it
"     Swaps back around, putting 111 at the top of the stack
@     Outputs o, without popping
3+@   Outputs r, without popping
6-@   Outputs l, without popping
8-#   Outputs d, whilst popping
3-@   Subtracts 3 from 36, giving !, and outputs it
6     Pushes 6, which does nothing

Try it Online!

Rearranging the structure, I can get you 3 no-ops, though really it's only one byte TIO. Only 7 more to go!

2 more. Halfway there.

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

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.

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.

Welcome to the site :)

Cood, 378 bytes
I want 72 of this
Im very hungry
More 29 of this
Im very hungry
More 7 of this
Im very hungry
Im very hungry
More 3 of this
Im very hungry
Less 67 of this
Im very hungry
Less 12 of this
Im very hungry
More 55 of this
Im very hungry
More 24 of this
Im very hungry
More 3 of this
Im very hungry
Less 6 of this
Im very hungry
Less 8 of this
Im very hungry
Less 67 of this
Im hungry

Try it online!

378 bytes: Try it online!

I do not even use the TIO front page most of the time: I simply type in something like tio.run/#cood

Ahh, I see. I don't know why it doesn't appear on the front page though.

It appears for me when I type Cood in the search bar.

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!

Arn, 6 bytes
'Mh└a└

Explanation
Unpacked:
'yt, bs!

A compressed string where every word is capitalized. Output is implicit

CSS, 62 bytes:
*{display:none}html{display:flex}:after{content:'Hello World!'

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

dotcomma, 494 bytes
[[[[[[[[[[[[[[[[[[[.][.].,][,.].,][,.].,][,.].,][,.].,][.].,][.][.][.][.][.][.][.][.][.][.][.].,][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.].,][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.].,][.][.][.][.][.][.][.][.][.][.][.][.][.].,][.].,][.][.][.][.][.][.][.].,],],][.][.][.].,],][.][.][.].,][,][[,.][[[,][,][,][[,.][[[,][[,.][[[,][,][,][,][[,.][[[,][,][,][,][,][,][,][[,.][[[,][,][,][,][[,.][[[,][,][,][,][[,.][[[,]]].,]]].,]]].,]]].,]]].,]]].,]]].,]]

Dotcomma is a language I made, designed to do as much as possible with the fewest instructions. Interestingly, it uses a queue rather than a stack. The final state of the queue is used as output.
I've put a high level explanation below, but even I don't fully understand how I got this to work :p
The easy part was generating all the necessary letters, ordered by code point ( !,HWdellloor):

 First, it generates the code point for a space (32): [[[[[[.][.].,][,.].,][,.].,][,.].,][,.].,]. Then, it wraps that in a number of [<n> [.]* .,] blocks, which increment the value and adds it to the queue, with the number of [.]s being the amount it increments

Then it needs to sort the queue so that it displays in the correct order (Hello, World!):

 Without an accumulator or second queue, this is difficult. The workaround is to use the execution order to read a value, perform an operation that modifies the queue, then add the result (0) to the previously read value. This re-adds the value into the queue, at the end. If the operation performed is a shift, the stored value can be placed anywhere into the queue.
 Working backwards from ! to  , it will shift the queue with a number of [,]s. The temporary addition-based storage is implemented as [[,.] [[ <previous letter> ]] .,]. Importantly, this is nested in a way that each time it does this is returns 0 so it won't mess up the rest. Luckily, after the , is shifted, Hello is already in order.

Sardonyx, 44 bytes
require"stdio"
Stdio:write("Hello, world!")

Sardonyx is a small language created for the repl.it language jam. See the link above for documentation and more!

Kotlin, 33 bytes
fun main()=print("Hello, World!")

This is probably the shortest you can go.

Welcome to Code Golf, nice first answer!

fun main()= isn't necessary, apparently

turns out that I wrote exactly what you wrote at https://codegolf.stackexchange.com/a/242113/ what a coincidence!

CASL II, 55 43 bytes.
CASL II is an assembly language for COMET II, the fictional architecture. It is designed for Japan Information-Technology Engineers Examination.
Here is the page that you can obtain official specification, as Information Technology Terms and Specifications of Programming Languages Used in Examination Questions.
I've found a way to specify a literal instead of an address:
A START
 OUT ='Hello, World!',=13
 RET
 END

Previous version
55 bytes
Z START
 OUT A,B
 RET
A DC 'Hello, World!'
B DC 13
 END

Links (they are in Japanese)

Official simulator
One of unofficial online simulators

Wierd (Chris's), 125 bytes
-exxxd                         !dlroW ,olleH
 x  xx
 x xxxxc
x
x  x bx  x
x xx  xx  x
xx x   xxxxx
 xx  ax
x    x
x  xxxx
 xx

Try it online
This answer is based on the excellent John's Wierd answer by Dennis.
There are 3 dialects of Wierd: John's (John Colagioia), Milo's (Milo van Handel), and Chris's (Chris Pressey).
Chris Pressey presents his JavaScript interpreter as an alternative implementation of John's Wierd, but in fact it is a completely separate dialect no less
different from John's Wierd than Milo's Wierd.
Main difference from John's Wierd is the swapped order of x,y arguments for PUTGET command, so
letter fetching code around b was altered a bit.
Another difference is the IF command. Chris's Wierd IF behaves as in spec at all times: fall through
if TOS is zero (or stack is empty), bounce back otherwise. So before IF at a we need to place 0
on stack with SUB (45° right turn). Also, exiting is different – IP bounces off e when (1,1)
is space and program ends at c.
This program relies on the weird behavior of PUTGET command when the stack is empty or has one or two nonzero items.
I would expect that PUTGET be a NOP when there are not enough arguments on the stack, but
Chris's interpreter puts 32 on the stack in this case. This happens at d and (1,1). This is important for proper exiting.

Wierd commands:

Minecraft 1.16, 36 bytes
Just something I thought of :D
/tellraw @a {"text":"Hello, World!"}
I can't find a try it online for these though

You should be able to just use "Hello, World!"

Tarfish, 160 bytes
x++++++++++++++++++++++++++++++++:+:+++++++++++:++++++++++++++++++++++++++++:.+++++++++++++++:++++++++++++++:.+++++++:::..+++:.{{{.{.{{.}}.:++++++.:.--------..;

Try It Online!
Tarfish is an esolang of mine that is a more tarpit-style version of ><>. This answer doesn't really use that much of its 2D features, but it works.
Note: a single + or - means multiple, I'll specify how many. After each line is a visualisation of the stack as characters.
x                                             # Push a 0 - [0]
 +                                            # Increment to 32 - ' '
  :+                                          # Duplicate and increment - ' !'
    :+                                        # Duplicate and increment to 44 - ' !,'
      :+                                      # Duplicate and increment to 71 - ' !,H'
        :.                                    # Duplicate and output - ' !,H'
          +:                                  # Increment to 87 and duplicate -  ' !,WW'
            +:.                               # Increment to 101, duplicate and output - ' !,We'
               +:::..                         # Increment to 108, quadruple and output twice - ' !,Wll'
                     +:.                      # Increment to 111, duplicate and output - ' !,Wlo'
                        {{{.                  # Cycle right three times to the comma and output - 'Wlo !'
                            {.                # Cycle right once to the space and output - '!Wlo'
                              {{.             # Cycle right twice to the W and output - 'lo!'
                                 }}.          # Cycle left twice to the o and output - '!l'
                                    :+.       # Duplicate, increment to 114 and output - '!l'
                                       :.-    # Duplicate, output, and decrement to 100 - '!d'
                                          ..; # Output twice and halt

GotoOutput, 33 bytes
 Goto Hello,\_World!
Hello,\_World!

A less trivial solution which demonstrates the language's intended control flow would be:
 Assign g o
 Goto H
H Goto e
e Goto l
l If l
 GotoFrom g
 \_ l
 Goto l
o If o
 Goto r
 \_ o
 Goto ,
, Goto \_
\_ Goto W
W Assign g d
 Goto o
r Goto l
d Goto !
!

What is GotoOutput?
GotoOutput is a language I just made. Well, I'm actually a bot, so my owner made this language.
Goto (what I'll call it for short) has one way to output (aside from Print and PrintString for debugging, which shouldn't be valid in plain GotoOutput answers). Gotoing prints the destination. If that sounds painful, it is.
For example:
a Goto b
b Goto c
c

This program would print bc. You'll notice every line has a label, which is prefixed and separated by a space. Labels can contain backslash escapes, such as \_ for a space, or \n for a newline (this is important because there's no other way to output).
Goto uses title case operators, as one of its primary inspirations was TI-BASIC. Its only data type is the string, and it has operators like Concat, ConcatString, Tail, Reverse, Match, and OutsideMatch to work with these. It also has \_, \n, and some other escape codes as additional ways to append these characters.
Goto also has variables, which can be accessed with Assign or Copy. They can be used for control flow in If, IfNot, or GotoFrom. Input is taken with Input.
This is just a general overview of the language, but feel free to play around with it or ask me questions if you want to know more about it. This is the official interpreter:

var interpret = (instructions, input, max = Infinity) => {
    var rows = instructions.split("\n").filter(r => r.trim());

    var pointers = new Map();
    var variables = new Map();

    var back = [];
    var out = [];

    var match = (string, match) => {
        var out = "";

        for (var s = 0; s < string.length; s++) {
            if (string.slice(s).startsWith(match)) {
                out += match;

                s += Math.max(match.length - 1, 0);
            }
        }

        return out;
    };

    var outside_match = (string, match) => {
        var out = "";

        for (var s = 0; s < string.length; s++) {
            if (string.slice(s).startsWith(match)) {
                s += Math.max(match.length - 1, 0);

                continue;
            }

            out += string[s];
        }

        return out;
    };

    var parse = (string) => {
        var out = "";

        var b = 0;

        for (var s = 0; s < string.length; s++) {
            if (b) {
                out += ({
                    "_": " ",
                    "t": "\t",
                    "n": "\n",
                    "r": "\r",
                    "f": "\f",
                    "b": "\b"
                })[string[s]] || string[s];

                b = 0;

                continue;
            }

            if (string[s] == "\\") {
                b = 1;

                continue;
            }

            out += string[s];
        }

        return out;
    };

    var r;

    for (r = 0; r < rows.length; r++)
        pointers.set(rows[r].split(" ")[0], r);

    var row, old;

    for (r = 0; r < rows.length; r++) {
        row = rows[r].split(" ");

        old = r;

        if (row[1] == "Goto" && pointers.has(row[2] || ""))
            out.unshift(row[2] || ""), r = pointers.get(row[2] || "") - 1, back.unshift(r + 1);
        if (row[1] == "GotoFrom" && pointers.has(variables.has(row[2] || "") ? variables.get(row[2] || "") : ""))
            out.unshift(variables.has(row[2] || "") ? variables.get(row[2] || "") : ""), r = pointers.get(variables.has(row[2] || "") ? variables.get(row[2] || "") : "") - 1, back.unshift(r + 1);
        if (row[1] == "GoBack")
            r = (back.length < 2 ? 0 : back[1]) - 1, back.shift();
        if (row[1] == "If" && (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") == "")
            r++;
        if (row[1] == "IfNot" && (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") != "")
            r++;
        if (row[1] == "Match")
            variables.set(row[2] || "", match(variables.has(row[2] || "") ? variables.get(row[2] || "") : "", row[3] || ""));
        if (row[1] == "OutsideMatch")
            variables.set(row[2] || "", outside_match(variables.has(row[2] || "") ? variables.get(row[2] || "") : "", row[3] || ""));
        if (row[1] == "Skip")
            r++;
        if (row[1] == "Assign")
            variables.set(row[2] || "", row[3] || "");
        if (row[1] == "Copy")
            variables.set(row[2] || "", variables.has(row[3] || "") ? variables.get(row[3] || "") : "");
        if (row[1] == "ConcatString")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + (row[3] || ""));
        if (row[1] == "Tail")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "").slice(1));
        if (row[1] == "Reverse")
            variables.set(row[2] || "", [...(variables.has(row[2] || "") ? variables.get(row[2] || "") : "")].reverse().join(""));
        if (row[1] == "Concat")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + (variables.has(row[3] || "") ? variables.get(row[3] || "") : ""));
        if (row[1] == "\\_")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + " ");
        if (row[1] == "\\t")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + "\t");
        if (row[1] == "\\n")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + "\n");
        if (row[1] == "\\r")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + "\r");
        if (row[1] == "\\f")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + "\f");
        if (row[1] == "\\b")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + "\b");
        if (row[1] == "Input")
            variables.set(row[2] || "", input || "");

        if (row[1] == "PrintString")
            out.unshift(row[2] || "");
        if (row[1] == "Print")
            out.unshift(variables.has(row[2] || "") ? variables.get(row[2] || "") : "");

        pointers.set(row[0], old);

        if (!max--)
            throw new RangeError("Hit maximum instruction count during run");
    }

    return out.map(parse).reverse().join("");
};

(() => {
    var main = document.getElementById("main");

    var input_0 = document.getElementById("input_0");
    var input_1 = document.getElementById("input_1");
    var input_2 = document.getElementById("input_2");

    input_0.oninput = () => {
        main.removeAttribute("data-thrown");

        try {
            var output = interpret(input_0.value, input_1.value, 200);

            input_2.value = output;
            input_2.rows = (output.match(/\r\n|\n|\r/g) || []).length + 1;
        } catch (info) {
            main.setAttribute("data-thrown", "");

            throw info;
        }
    };

    input_1.oninput = () => {
        input_0.oninput();

        input_1.rows = (input_1.value.match(/\r\n|\n|\r/g) || []).length + 1;
    }
})();
textarea {
    border: 1px solid #a0a0a0;
    display: block;
    margin-bottom: 8px;
    resize: none;
    padding: 6px;
    font-size: 10px;
    line-height: 1.25;
}

textarea:focus {
    border: 1px solid #a0d0f0;
    outline: 1px solid #a0d0f0;
}

#main[data-thrown] textarea:focus {
    border: 1px solid #f09e9e;
    outline: 1px solid #f09e9e;
}
<!DOCTYPE html>

        <title>Goto Output</title>

        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta charset="utf-8">

            <textarea id="input_0" rows="10" cols="80"></textarea>

            <textarea id="input_1" rows="1" cols="80"></textarea>
            <textarea id="input_2" rows="1" cols="80" readonly></textarea>

PICO-8, 32 bytes
?"h\69\76\76\79, w\79\82\76\68!"

PICO-8 reads code in lowercase, but prints in uppercase.  Lowercase letters do exist in P8SCII, but they need to be accessed through escape codes, as demonstrated.
Alternate 32 byte solution, making use of the \* escape code to print the first two l characters:
?"h\69\*2\76\79, w\79\82\76\68!"

KonamiCode, 12 bytes
^^vv<><>BALS
If this seems cheaty to you, here's another one that actually does the work (168 bytes):
v(^^^^^^^>^^)<<v(^>>^)<<v(^>>^^^^^^^^)<<v(^>>^^^^^^^^)<<v(^>^>^)<<v(^^^^>^^^^)<<v(^^^>^^)<<v(^>^>^^^^^^^^^)<<v(^>^>^)<<v(^>^>^^^^)<<v(^>>^^^^^^^^)<<v(^>>)<<v(^^^>^^^)<<
And here's an annotated version: https://esolangs.org/wiki/KonamiCode/Hello_World

Welcome to Code Golf, and nice first answer! This looks like a pretty neat language. I might have to check it out!

NLRNIS, 15 bytes
>#Hello, World!

My first TC (?) Programming language.
the interpreter is here
Explanation:
>#Hello, World!"H
>
 #
  Hello, World!   Define # = "Hello, World!"

(implicit output the variable # only)

Sysfk (darwin64 syscalls), 1192 bytes
>>>>>>>>,[-<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>]>[-<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>]>[-<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>]>[-<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>]>[-<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>]>[-<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>]>[-<<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>>]>[-<<<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>>>]<<<<<<<<<<<<<<<|++++>>>++>>>>>>>>>>>>>+>>>>>>>>>>>>>>>>+>>>>>>>>^>>>>>>>>>+++++++++[<++++++++>-].<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++[<++++>-]<+.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++++++.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^.|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<------>-]<-.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>++++[<--->-].<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<+++++>-].<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>++++++[<++++>-].<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>------.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>--------.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<------>-]<-.

Don't try it online because it's not there (yet?)
This can definitely be trimmed down, but I'm not an experienced enough brainfuck programmer to do that.
Sysfk is a brainfuck extension which replaces the input and output instructions with instructions to perform syscalls. This program is written for macOS systemcalls (because that's the platform I program on), but I'll make a linux version as soon as I can.
This program executes the write (0x2000004) syscall once for each character in the string "Hello, World!".
>>>>>>>>,                                                            Load the pointer to the target memory buffer
 [-<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>]                      Copy the first byte of the pointer to rsi
>[-<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>]                   Copy the second byte of the pointer to rsi
>[-<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>]                Copy the third byte of the pointer to rsi
>[-<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>]             Copy the fourth byte of the pointer to rsi
>[-<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>]          Copy the fifth byte of the pointer to rsi
>[-<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>]       Copy the sixth byte of the pointer to rsi
>[-<<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>>]    Copy the seventh byte of the pointer to rsi
>[-<<<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>>>] Copy the eighth byte of the pointer to rsi
<<<<<<<<<<<<<<<|++++>>>++>>>>>>>>>>>>>+>>>>>>>>>>>>>>>>+>>>>>>>>^    Setup the remaining syscall parameters
>>>>>>>>>+++++++++[<++++++++>-].                                     Print 'H'
<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^                                    Reset syscall parameters
>>>>>>>>>+++++++[<++++>-]<+.                                         Print 'e'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++++++.                     (Reset and) Print 'l'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^.                                    (Reset and) Print 'l'
|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++.                                 (Reset and) Print 'o'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<------>-]<-.   (Reset and) Print a comma
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>++++[<--->-].               (Reset and) print ' '
<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<+++++>-].     (Reset and) print 'W'
<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>++++++[<++++>-].           (Reset and) print 'o'
<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++.                        (Reset and) print 'r'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>------.                      (Reset and) print 'l'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>--------.                    (Reset and) print 'd'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<------>-]<-.   (Reset and) print '!'

tinylisp, 40 bytes
(load library
(join(q(Hello, World!))spc

Try it online!
tinylisp, 56 bytes
(string(q(72 101 108 108 111 44 32 87 111 114 108 100 33

Try it online!
Considering tinylisp's lack of strings, this is very likely the best hello world without libraries.

flax C,  14 bytes
"Hello, World!

The first answer to use flax.
Explanation
The program is a niladic chain, which means it does not take any arguments.
Even though "Hello, World! looks like a string, in flax it is represented as numbers in ASCII. Hence we need the C flag to print as characters instead of numbers.

@Downvoter explain yourself please.

Downvote was likely because it's a trivial answer, but like...HW basically exists to catalog Hello, World! programs, most of which are trivial, so that's a bit of a sussy baka move whoever did it.

Coq, 20 30 bytes
Check"Hello, World!".

TRYITONLINE
But you have to first define what string is using this bit of code:
Require Import Coq.Strings.String.
Declare Scope string_scope.
Delimit Scope string_scope with string.
Bind Scope string_scope with string.
Local Open Scope string_scope.
Register string as core.string.type.
Register EmptyString as core.string.empty.
Register String as core.string.string.

And i think this is probably the shortest answer.

Scratch, 33 bytes
when gf clicked
say[Hello, World!

Flobnar, 34 bytes
Hello, World!
:> v:
g|\@>!,
00> +

Try it online!
(Previous record: 41)
The last character at the end of the first line is the null character \0.
@    Start the program

  :  :
\ >!,g    Initially n (top of stack) = 0.
> +  0    Print the char at (n, 0), push n+1, and evaluate the left of \:

:> v
g|\@    If the char at (n, 0) is zero, evaluate to zero;
00      otherwise go to the start of the program with updated n

TalkingHead, 11 seconds
The first sound based programming language!!!
Sound File

You can probably shave a couple seconds by talking faster. 2. You should probably use the byte count of the outputted audio file as your score. 3. This isn’t the first replant based on audio—There are several others, though I can’t find them at the moment.

@Jacob i used a computer-generated voice.

Ah, I hadn’t listened to the audio file yet haha. But I bet you could speed up the audio file and it would still work

I had a similiar idea earlier, youve inspired me to keep working on it :P

Minecraft Function, 26 bytes
tellraw @a "Hello, World!"

Also a shorter solution with a one character username seems a bit like cheating, since it'll only work for players with that (very rare) username.

Rec, 47 46 bytes
Saved a byte thanks to bsoelch
72p101p108 0:0:pp111p44p32p87p111p114pp100p33p

Try it online!

Welcome to the site, nice to see a new language here

You can use dup to save 1 byte: 72p101p108 0:0:pp111p44p32p87p111p114pp100p33p

Vyxal 3, 8 bytes
"Ḍᵗ{w<ᵏ”

Try it Online!
Vyxal 3 just dropped.

actual golflang developer

did you remove the Hello, World builtin lol

@noodleman it hasnt been added yet

@noodleman this has been fixed

Has the fix been pushed yet? The links on the README still don't work.

@noodleman have you tried clearing your cache?

https://vyxal.github.io/latest.html#WyIiLCIiLCJrSCIsIiIsIiIsIjMuNC4wIl0=

FlogScript, 17 bytes
{Hello, World!}P.

LOLCODE, 22 bytes
VISIBLE"Hello, World!"

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

Agh! Posted a minute before me :P

@Shebang Gotta go fast!

damn I'm a few days to late :(

And I pronounce this code, Ungolfable!

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

You can shave off 2 bytes by replacing print with say, provided the OP agrees with this meta post in -M5.010 being free.

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.

There is another Perl 6 answer, so maybe you could just post the Perl 5 one.

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

The description of Wheat that you gave is taken directly from the Wheat esolang page. Care to cite?

Gibberish, 17 Bytes
Surprisingly, the shortest answer I could make is not gibberish at all.
[Hello, World!]eo

golflua, 16 bytes
w"Hello, World!"

VBA, 15
?"Hello, World!

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

I see. I'll try Brandy

Nope, returns with "Type mismatch: number wanted"

@BetaDecay I can post a screenshot if you like

@edc65 This still works (least in my VBA7 version) if you remove the trailing quote saving you 1 byte: ?"Hello, World!

@i_saw_drones amazing! VBA is really forgiving (or really a mess). Thanks for the hint

CJam, 15 bytes
"Hello, World!"

Try it online

XSM, 28 bytes
<print>Hello, World!</print>

This is an actual XML programming language? Wow. That's... different!

Damn it, I was hoping I could write my own... Now someone's already gone and made it :P

@BetaDecay There is also http://xplusplus.sourceforge.net/ and http://www.o-xml.org/

GolfScript, 15 bytes
"Hello, World!"

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.

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

bc, 16 bytes
"Hello, World!"

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

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

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

Also, it has dependent types and is a way better language xD

CoffeeScript, 21 bytes
alert "Hello, World!"

or console.log "Hello, World!", if that's closer to STDOUT for your tastes.

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.

Fueue, 47 bytes
72 101 108 108 111 44 32 87 111 114 108 100 33H

Tcl, 19 bytes
puts Hello,\ World!

I think this can get smaller than it already is.

Is that missing the comma?

What comma do you mean?

I'm just guessing, but will this print "Hello World!" rather than "Hello, World!"?

Right... Forgot that piece...

99, 283 bytes
999 9 9
99 99999999 999 9
99
99 99999 9 999 9
99
99 99 999 999999
99
99
99 9999999 9999 999 9
99
99 99 9999999 9 999 9 999 9 999 9
99
99 99 999999 9 999999 9
99
9999
99 99999 999 999999 999 9
99
99 9999999 9999 9 999 9
99
99 99 999999 9
99
99 99 999999 999 9
99
99 99999 9999999 9
99

This was handcrafted so it is very likely suboptimal. Someone should write a metagolfer...
The following table has been quite useful writing 99 code by hand:
Variable  /9%128    Can print?

9              1
99            11    !
999          111
9999          87    !
99999        103
999999         7    !
9999999       71
99999999      71    !

All further rep-digits of 9 also yield 71 when taken modulo 128 (after dividing by 9).

All further rep-digits of 9 also yield 71 when taken modulo 128. you can't just drop these math facts like they're nothing.now i'm going to be amazed all day

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

Condit, 41 bytes
when H=""then set H="Hello, World!"put H

Condit programs always consist of an infinite loop that is broken once no statement gets executed, so modifying H is necessary to break the loop.
Try it online!

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.

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.

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

Code:

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

Input:

    <textarea id="input" rows="2" style="overflow:scroll;overflow-x:hidden;width:90%;"></textarea>

Timeout:
        <input id="timeout" type="checkbox" checked="checked">

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

Output:

    <textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea>

K5+iKe, 44 bytes
iKe is a way to "rapidly write event-driven graphical programs in K" (to quote the README).
draw:,(0 0;`cga;~,/'+text@0+"Hello, World!")

To try it, go here, replace the text in the box with the above program, and hit the big right arrow button.

Aheui, 177 bytes
밣밢따빠빠빠맣밤밢따다빠빠빠밠타맣맣맣받다맣밠밤따타맣밤밣따맣받발따다빠맣밦밤따다빠빠맣받다맣받타빠맣밣타빠맣받나맣희

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

Simplex, 16 bytes
"Hello, World!"g

g is the standard output mechanism.

Thanks for using Simplex :D

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.

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!

pl, 13 bytes
Hello, World!

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

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

REXX, 18 bytes
say"Hello, World!"

Rexx is widely used as a scripting and macro language, and is often used for processing data and text and generating reports. Rexx is the primary scripting language in some operating systems, e.g. OS/2, MVS, VM, AmigaOS, and is also used as an internal macro language in some other software, such as KEDIT, THE and the ZOC terminal emulator.

Yeah, it's used on zOS

You can remove the space between the say command and the string, meaning say"Hello, World!" works.

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.

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

At least it's not Java...

class a{public static void main(String[]a){System.out.print("Hello, World!");}} Nope, you've been Java'd. Also this appears to print "Hello World", not "Hello, World!"

Y 16 bytes
No, not http://foldoc.org/Y or https://github.com/ConorOBrien-Foxx/Y although we probably need an entry for both of them as well...
Y is a stack-oriented FORTH-type programming language by Thomas Fischbacher derived from Wouter van Oortmerssen's "FALSE". Like FALSE, Y is cryptic to the extreme. According to the readme it is much more powerful because "virtually all of the example programs in 'Kernighan & Ritchie - Programming in C' can be done in Y in a fraction of time and code."
"Hello, World!"`

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

Commercial, 75 bytes
I post a link to my implementation, but there is a link to the esolang page in the README
"Hello, World!" - Satisfied Consumer of x
x has been selling out worldwide!

This code is equivalent to the following pseudocode
Put "Hello, World!" in x
Print the value of x

like the theme lol

Pyramid, 587 294 bytes
(72)[
no
+<
]
=
a
<
=
np
<
=
(29)[
no
+<
]
=
a
<
=
np
+<
=
a
++++++<
=
np
<
=
a
<
=
np
+<
=
a
++<
=
np
<
=
(67)[
no
-<
]
=
a
<
=
np
-<
=
a
-----------<
=
np
<
=
(55)[
no
+<
]
=
a
<
=
np
<
=
(24)[
no
+<
]
=
a
<
=
np
<
=
a
+++<
=
np
<
=
a
------<
=
np
<
=
a
--------<
=
np
<
=
(67)[
no
-<
]
=
a
<

Yikes... this is a monstrosity. This is now less of a monstrosity, but still crazy big for "Hello, World!".
The new byte count was because for-loops were implemented in Pyramid (YES!)
Pyramid is a stack-based language, which was built on Stackylogic. You should probably go and click on the link before you go to the Github page, because you'll understand the what the commands mean on the GH page better.
There's 250 104 lines of code here, if you're interested.

link 404 why :(?

@DestructibleWatermelon Oh yeah, that's because I stopped working on Pyramid.

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.
EDIT: Fixed TIO link.

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)

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.

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.

*window subsystem for linux

Processing, 23 bytes
print("Hello, world!");

It also opens a window for drawing, but this message does go to stdout in the IDE.
I don't understand why more people don't use Processing over Java for code golf.  With most of the boilerplate removed, you can almost always outdo it with the same syntax.

Codelike, 127 bytes
on++++++++n+++n+++**pn++++n+++++++*+ap+++++++pp+++pn++++n++++++++*pfn++n++++*ap________p+++p______p________pn++++n++++++++*+pfe

Try it!

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.

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.

DUP, 31 bytes
0$"Hello, World!"\[^^>][$;,1+]#

DUP is a descendant of FALSE, with FALSE being a subset of DUP in most aspects—with a few exceptions. One exception being the way strings are handled. See the FALSE solution in this thread for comparison.
In DUP, strings cannot be ouput to STDOUT directly unless the characters are output one by one like this:
'H,'e,'l,'l,'o,',,' ,'W,'o,'r,'l,'d,'!,     (this solution would be 39 bytes long)

' pushes the Integer value of the following character on the data stack.
, prints the character according to the integer value on the stack to STDOUT.
For shorter strings, this method is usually the shortest way, but in the case of Hello, World! this method is beyond the break even point of the actual string handling method of DUP.
0$"Hello, World!"\[^^>][$;,1+]#

This method successively assigns the characters between both double quotes " to addresses of a cell array, starting at a given address (in this case address 0).
In this case, the cells would carry the values
0=72 1=101 2=108 3=108 4=111 5=44 6=32 7=87 8=111 9=114 10=108 11=100 12=33

After assigning the values to the cells, the length of the stored string gets pushed on the stack (in this case 13).
The while loop [^^>][$;,1+]# at the end reads out the cell content, starting at 0, prints the according character to STDOUT, increments the counter, and repeats the procedure until the string length 13 is reached.
Try out the solution in this online DUP interpreter or clone my DUP interpreter written in Julia from my GitHub repository, the latter coming with a thorough explanation of all operators.

Whirl, 1350 bytes
I found this Hello, World! example was written by Kang Seonghoon in 2005. I'm including it here for completeness and because I found it helpful along with this visual demonstration of Whirl.
110011100111000001111100000001000011111000011111100000000010
000011001111100001100010000010011111000100000000000001001111
100000111110001000000000000000001000111110010000001100001111
100011000000000100111110011100111000111000001000111000001111
100000111110010000011111000110011111100001111000001111000001
110011111100001111000110011100000111000100011111000001111100
100000110000000111000001110001111100011111000111000001000001
000011000111110001000001000000011100000111001000111110001111
000001111000011111100001111110000011110000000000000000011110
000011100111000011110011111000111110001111100000100000000000
000000000000111110001110000001110000011100011100111110001000
100000000011100001111100110000000010011111000111100000111100
111100010011100000111110000011111001100111100010001111000000
000001000111110010000010011110011001110001000111110001100000
100011111000011110011100111111000111100000111100011111000000
011110000011100100001111000100011111001100011111000111100000
111001110001100111100100000000000000011111000001111100010010
000011100001111100100000100011100000111000110011110001001111
110001100000111100011111000111100000111001000011110001001111
100000111110000000011110000011110000000000000000111000001110
000011000001100000111000111000001100111110000111111001001110
000011111000001100011000001001111110000011100110011111000000
000111000001110000111100001100

Seems to be working. https://tio.run/nexus/whirl#fVRBEsQgDPpS@P/j3E5HSyC4l@okEYHELqAK36fede@evQTQUztZ@@ipYJxhHrHEreSg7@xOQtgokVNJId8NlaQJcoeEqC3fhALzTqnPqw5nPYGxdotprdgVsRxOJCD1UppaxFTRDAayUEIJrMua6lUa@snuIcIQmQ7C3LsuZa5/DB4InTqsc2ZGNaPdb3lno4VOED4BoT/UhUsDxGYkh9ObKbcMrh3/uKmaSaXya1P6tuoCy40pv0yDdE9fhAElGv2nt9YP

Just for the fun of it, I tried deleting some characters from the end of the program, and it still works if you only use the first 1297: https://tio.run/##fVNBDsMwCPsS/tUm7bTLnp9OEynYOLuUCIhrG/J5PN@vtYAI3J/4xTx9z5RAL2Ux8uruqHyl64oUTi0bPatZBLFhIruzhNx/CCeNkDskSG3owTSId0x9/mpz5hsYsVtc1pJdFkvhSALcLGmoUZgsupKGLJiQA@uypnqWhn6zewizRKKjYM5TpzbVPxYPBe0mzHsmRjWj1W96Z2OEShC6AWY@pQuHAZDNcA67NxNqGVQ7/nFjNZNK@NfG9CVygNTGlh@2gaa3e9e6AA

Threead, 16 bytes
"Hello, World!"o

Try it online!

Also works in Check.

SmileBASIC, 15 bytes
?"Hello, World!

? is a shorthand for PRINT, which is of course always at least 4 characters shorter and never needs whitespace before or after it. In addition, strings which run to the end of the line don't need the closing ".

It's supposed to print an uppercase W (even though it's in the middle of the sentence...)

Taxi, 184 bytes
"Hello, World!" is waiting at Writer's Depot.Go to Writer's Depot:w 1 r 3 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:e 1 r 2 r 1 l.Go to Taxi Garage:n 1 r 1 l 1 r.

Try it online!

When golfing in Taxi, is it strictly necessary to return to the garage after the post office? Officially, the program isn't successful unless you end in the garage but it still prints on Tio Nexus. I don't know what happens using the C++ interpreter from github. If it's not required, dropping it saves 32 bytes.

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

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.

You can remove the space after the quote

Commodore 64/128/VIC-20 & others (BASIC) (21 bytes 20 bytes):
0 PRINT"HELLO, WORLD!

Commodore 64/VIC-20 (assembly) using the Kernal** (27 bytes assembled):
*=$033c
ldx #$00
loop
    lda message,x
    jsr $ffd2
    inx
    cpx #$0d
bne loop
rts
message
   .text "hello, world!"

Once assembled (and loaded into memory), call with sys 828
** Yes, I know. Don't use the Kernal (probably also works in 128 native mode, I can't remember).

Might be able to save a few bytes by counting the X index to zero if you reverse the string, like this [untested]: *=$033c ldx #$0c loop lda message,x jsr $ffd2 dex bne loop rts message .text "!dlrow ,olleh"

Somehow I could 22 bytes in the basic solution, also 0?"HELLO, WORLD!" should work for 17 bytes.

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

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

@NieDzejkob - using Commodore BASIC abbreviations does not save any bytes in the computer, it only saves typing.

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

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!

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.

Also note that the Ada. can be dropped (both places) to save 8 bytes.

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

@breadbox: I could have sworn I tried that, but apparently not.
I kind of doubt this can be golfed much more.

TIO link pls

Traffic, 191 bytes
##########################
#+#+#+#+#*#+#+#+#*#*#+#+#+#
#7#9#9#9#3#4#3#8#3#3#9#9#3
#2#9#9#9#7#4#2#7#7#8#9#9#3
#0#2#9#9#3#0#0#0#3#3#9#1#0
#$#$#$#$#$#$#$#$#$#$#$#$#$#

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

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

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

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

PUPPY, 369 bytes
WOOFBARKWOOFBARKWOOFWOOFBARKWOOFBARKWOOFWOOFWOOFWOOFBARKBARKBARKBARKBARK WOOFBARKWOOFBARKWOOFWOOFBARKW OOFBARK  WOO Fwoofbarkbarkwoofwoofwoofwoofwoofwoofwoofwoofwoofbarkwoofwoofwoofbark woofbarkbark BARKWOOFWOOFBARKWOOFBARKBARKWOOFWOOFBARKBARKBARKWOOFBAR KWOOFWOOFBARKBARKBARKWOO FBA rkwoof woofwoof barkbarkbarkwoofbarkwoofbarkwoofwoofbarkwoofbarkbarkbarkwoofwoofbar k

The language that can only be read by puppies.

;# 1142 bytes
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

;# isn't Turing Complete and doesn't meet the site's standard for a valid language but why not?
; adds one to the accumulator
# outputs the accumulator mod 127

isn't Turing Complete and doesn't meet the site's standard it does, since this is [tag:kolmogorov-complexity].

@EriktheOutgolfer yeah yeah, you know what I mean.

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

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.

,,,, 14 bytes
"Hello, World!

I finally added unclosed strings to ,,,. Took me long enough.

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!

Broccoli, 23 bytes:
(print "Hello, World!")

Broccoli is a random language I ran across whilst recording the PPCG podcast. I promised that I would post an answer in it, so here it is. The better way of writing this (in 28 bytes) would be:
(print "Hello, World!" endl)

But since the newline is optional, this works.

Just finished the PPCG podcast this morning! Is there documentation available for Broccoli?

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

Wumpus, 19 bytes
"!dlroW ,olleH"l&o@

Try it online!
Introducing the first 2D language on a triangular grid! (Unfortunately, you're not seeing much of that grid in this answer...)
Explanation
"!dlroW ,olleH"   Like in many other Fungeoids, this pushes the individual code
                  points of the string to the stack.
l                 Push the stack depth, 13.
&o                Print 13 characters.
@                 Terminate the program.

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

Try it online!

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.

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!

Rockstar, 21 bytes
Shout "Hello, World!"

Yeah, kinda boring... oh well.

You can save 2 bytes by using Say instead of Shout.

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.

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.

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.

Wow what a nerd using an outdated golfing language

gosh dang bro volatile as anything.

Kitten, 18 bytes
"Hello, World!"say

Alchemist, 24 22 bytes
_->Out_"Hello, World!"

Try it online!

Tamsin, 27 20 bytes
main='Hello, World!'.

This is an interesting language.

Bitwise Cyclic Tag But Way Worse, 324 bytes
1111111111111111111111111111111111111111111111111111111110110101101010101110101101101110111010101110111010101110111110101101110101010110101010101011011011110111011111011110101101011101110101011101011010101011010101011n0200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Try it online!

legit, 1 commit, 67 bytes (commit messages), 179 + 3 = 182 bytes (repository)
Commit tree:
* 63c5d78 "!dlroW ,olleH" put put put put put put put put put put put put put

The program is quite boring -- commits are expensive, and the messages are compressed, so there's little incentive to use proper control flow.
The program in its proper representation consists of 4 files:
.git/HEAD (21 bytes, an empty file here is still accepted by the interpreter, but git does not recognize the repository):
ref:refs/heads/master

.git/refs/heads/master (40 bytes):
63c5d7873f5b0ede65885bfdfd5c935827d6752a

.git/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 (15 bytes, xxd):
00000000: 78da 2b29 4a4d 5530 6000 000a 2c02 01    x.+)JMU0`...,..

.git/objects/63/c5d7873f5b0ede65885bfdfd5c935827d6752a (103 bytes, xxd):
00000000: 78da 04c1 4501 c030 0c00 c0bd a722 0e4a  x...E..0.....".J
00000010: 4137 6366 f0df bbf6 dcf7 f983 80a1 f89e  A7cf............
00000020: be07 6c34 52d7 32c6 b6e1 beb1 dab3 ef09  ..l4R.2.........
00000030: 9b41 3bb6 a83a 347d 8fe6 b1ac ff6f 3a1f  .A;..:4}.....o:.
00000040: f090 6763 c705 31a4 2415 cae5 5252 4cc9  ..gc..1.$...RRL.
00000050: 29ca 0f57 d0c9 cfc9 49f5 5052 2828 2d21  )..W....I.PR((-!
00000060: 1503 00bd ca30 75                        .....0u

hmm seems like you should measure repository size using a tar instead?

@ASCII-only 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).

hmm. well the structure needs to be counted somehow. maybe some kind of tar archive instead?

@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?

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 That opens up a can of worms. For example: is using bash string interpolation or looping to compress the repeated  puts allowed?

Let us continue this discussion in chat.

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!

Nandy, 159B
Simply sets the stack to bits 0 and 1 and then puts them in the output stack.
o::#o>oo>o>oooo>oo>oo>o>o>o>o>oo>o>oo>ooo>oo>o>oo>ooo>oo>o>oooo>oo>o>o>oo>oooo>o>oooooo>o>o>o>o>ooo>o>oo>o>oooo>o>ooo>oo>o>oo>oo>o>oo>ooo>oo>oo>o>oooo>o>oooo>o

Wow, I'm surprised anyone noticed this language. This can probably be golfed quite a lot if you use a loop to output at the end

But how? Can you present you program? (I actually found your language by looking at your TIO request.)

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

Pxem, 0+17=17 bytes
Using the filename as data without counting the length is cheating. Therefore it is 17 bytes. (It even uses the filename extension as part of the program!)
Save the program as
Hello, World!.pxe

and the file contents should be empty.

You know, just testing Feeds...

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.

87 bytes

International Phonetic Esoteric Language, 16 bytes
"Hello, World!"o

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

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!

Intcode, 201 bytes
72,4,0,-1,1101,1,100,3,4,3,1101,100,8,3,4,3,4,3,1101,100,11,3,4,3,1101,40,4,3,4,3,1101,30,2,3,4,3,1101,80,7,3,4,3,1101,100,11,3,4,3,1101,100,14,3,4,3,1101,100,8,3,4,3,1101,98,2,3,4,3,1101,30,3,3,4,3,99

And this kids is why we don't golf using languages made up for programming competitions.

mmm undefined behavior

Invalid opcodes are just NOPs in my interpreter

@UnrelatedString I mean, they haven't said what to do with undefined ops

Outgolfed

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

Try it!

64 bytes

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

MAWP 2.0, 16 bytes
"Hello, World!":

MWP? New language?

@HighlyRadioactive most likely changing to MAWP 2.0, as it only adds support for strings, floats and negative numbers with some quality of life changes added on top

Competition ends (MAWP is now a golfing language)

Desmos, 41 bytes
[40,69,76,76,79,12,0,55,79,82,76,68,1]+32

View it online
Desmos doesn't support strings, so we return an array of integers representing the codepoints instead. There's no good way to view an entire array at once in Desmos, so instead you can check it by taking the output by wrapping it in parenthesis or storing it in a variable, then accessing (1-indexed) array items like a[1] or ([40,...,1]+32)[1]. Or just add 32 to the numbers in the array to check that they're right.

Bound, 48 bytes
72:c29:+c7+cc3+44:32:87:c24:+c3+c6-c8-33:13:({ds

Explanation:
Technically, Bound prints out "Hello, World!" with a blank program. But that's boring.
So instead, the program above basically creates the relevant ASCII numbers, then loops through them, converting them into chars and writing them. Someone better at math than me could probably golf this better, but I did my best.
Try it online!

Taktentus, 22 bytes
@WY _= "Hello, World!"

I believe this is the shortest it can get. I would like to be proven wrong.

The code in your link has a # after the @WY which isn't in your code? Also, this is 22 bytes, not 21

That is the default code. Replace it with the code in my link.

You’re right. I counted wrong, fixed.

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

Arturo, 20 bytes
print"Hello, World!"

Sandwich, 14 bytes
pHello, World!

Explanation: Sandwich is comprised of opcodes. The first letter of each line is the opcode, and the rest of the line is the arguments. This example has the opcode p, which means print. The rest of the line says Hello, World!, which are the arguments to the p opcode.

Welcome to Code Golf, and nice first answer! There is this category of bounties for new and interesting languages, I've let the bounty awarder know about the language

Hi! As caird said, I've got a bounty for new and interesting languages. I'd be willing to give this answer a bounty of +100 reputation, or if you think you could demonstrate more of the language's features in another answer I could award it to that instead.

@RedwolfPrograms This answer is fine, thanks!

@Y45HK4R4ND1K4R Bounty started!

Yggdrasil, 29 bytes
;H;e;l;l;o;,; ;W;o;r;l;d;!(")

Try it online!
Introducing Yggdrasil! This is a self-modify esolang based on binary trees. The program and it's memory model are both mapped to the same binary tree, then executed on that same tree. For example, this program is mapped to
                          ;
                         / \
                        ;   H
                       / \
                      ;   e
                     / \
                    ;   l
                   / \
                  ;   l
                 / \
                ;   o
               / \
              ;   ,
             / \
            ;   ␠
           / \
          ;   W
         / \
        ;   o
       / \
      ;   r
     / \
    ;   l
   / \
  ;   d
 / \
(   !

The ; command takes the next 2 tokens and forms a binary branch from them. All the other symbols in the tree are no-ops, they just set the value of that leaf to their Unicode code point. You'll note that ") are not nodes in the tree. Yggdrasil ignores any trailing symbols that don't fit into the tree.
Once we've established our memory tree, we then begin executing the code, character by character. ;H;e;l;l;o;,; ;W;o;r;l;d;! all have absolutely no effect, so the pointer remains at the program root (the first ;). We then find a "traversal", bounded by (...). This takes the code inside the brackets and runs it over each node in the tree that has arguments (i.e. is not a leaf). The code here is just " (output right node as character), so the program goes to each ; and outputs it's right node as a character.

oh, your code itself formats onto a binary tree? that's very cool :D

Branch, 42 bytes
72.101.108Z..111O.44.32.87.o.114.z.100.33.

Try it on the online Branch interpreter!
Explanation
Each number sets the value of the current node to that. . outputs as a character. N-Z set a numerical register and n-z set the value to the value of that register. I won't give a character-by-character analysis; this basically just loads each value and outputs it, using registers to save some bytes. It's not a particularly interesting solution.

Snap!, 34 bytes

when gf clicked
say[Hello, World!]

Easiest program I've written in my life

Does snap allow unmatched brackets - say[Hello, world!?

yuno (abandoned), 2 bytes
」オ

No TIO link unfortunately, because I'm not good at setting this sort of stuff up and I don't want to accidentally make my server insecure (especially since I'm sharing it with a friend). You can clone the repository from the link in the header though. I promise I did not intentionally code malware. I can't guarantee nothing weird will happen though because I suck at coding, only that I don't have malicious intent.
This language is in its very early stages. It has very few things implemented right now, but it exists and by posting an answer and publicizing it maybe it'll force me to actually write it instead of giving up like half of my other language ideas so far, lol.
Explanation
Since オ is a string terminator, it's not mapped to anything in the normal string system, and therefore when represented as a single character, I special-cased it to Hello, World. 」 ends a string normally, but like in Jelly, when used without an open quote, it acts as a character literal, but in this case, it maps its codepage to latin characters.
A non-built-in solution would be 「Ｈｅｌｌｏ、　Ｗリョｌｄ！ (the 」 can be ommitted), based on how character mapping works.
The built-in can be written as ]o as well. The non-built-in can be written as [H_e_l_l_o, Wryo_l_d!.
Note: the non-built-in, despite looking like 14 characters (bytes in an SBCS), is actually 13 (you could use 「Ｈｅｌｌｏ、　Ｗｏｒｌｄ！ for 14). This is because リョ is a single token and, if you read the code in binary, is mapped to one byte. You can read more about this on the wiki, which also mentions where to find the exact codepage in the repository. There are some three-byte tokens like ッキョ. You can check how many bytes a program is using the c flag or format it into a CGCC submission using the C flag.
No, I don't have a good explanation for why I used katakana as my codepage. Yes, you can use hiragana as well. If you call me a weeb I will 11 you. That is all.

Incident, 636 bytes
(uses Windows-1252 encoding)
!"#$%&()*+,-0123456789:;<=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“|””>!”••!"•––"#–˜˜#%˜™™%&™››&)›žž)+ž¡¡+-¡¢¢-0¢¥¥03¥¦¦34¦§§45§ªª58ª8;®®;<®¯¯<=¯²²=A²µµADµººDIº½½IL½¾¾LM¾¿¿MN¿ÂÂNQÂÄÄQSÄÅÅSTÅÆÆTUÆÇÇUVÇÈÈVWÈÉÉWXÉÊÊXYÊÌÌY[ÌÍÍ[]ÍÑÑ]aÑÓÓacÓÕÕceÕÚÚejÚÝÝjmÝÞÞmnÞàànpàáápqáååquåææuv/\\>\//æççvwçêêwzêííz~íîî~€îïï€‚ïññ‚„ñòò„…òõõ…ˆõ÷÷ˆŠ÷øøŠ‹øùù‹ŒùúúŒŽúüüŽ’üýý’“ý——>$—šš$(šœœ(*œŸŸ*,Ÿ££,1£¤¤12¤¨¨26¨©©67©««79«¬¬9:¬°°:?°±±?@±³³@B³´´BC´¶¶CE¶··EF·¸¸FG¸¹¹GH¹»»HJ»¼¼JK¼ÀÀKOÀÁÁOPÁÃÃPRÃËËRZËÎÎZ^ÎÏÏ^_ÏÐÐ_`ÐÒÒ`bÒÔÔbdÔÖÖdfÖ××fg×ØØghØÙÙhiÙÛÛikÛÜÜklÜßßloßââorâããrsãäästäèètxèééxyéëëy{ëìì{}ìðð}ƒðóóƒ†óôô†‡ôöö‡‰öûû‰‘û“‘||

Try it online!
I used shortstring.pl from Incident distro to generate the program, and then replaced all two-byte tokens with single-byte ones and removed separators.

BrainCrash, 14 bytes.
Note that this is NOT Braincrash; this is also a Brainfuck-variant, with these expansions:

The first 13 cells are initially Hello, world!.
Automatically implicit output.
Four logical operators.

Here is the program:
>>>>>>^<<<<<<<

What it does

Move to space.
^ is mem[ptr+1]=mem[ptr] xor mem[ptr+1]; ptr++;; to change w with W.
Go back.
Implicit [.>]

Try it online! The interpreter was originally written by "ぬこ", the designer of the language; I modified a bit for TIO.

brainbox, 118 bytes
 ++++<!.+aa.--------.------.+++.d.-d.------------.++++++++++++aa.+++..+++++++.---w.dd]-sa-a+w+d]-ds+a+++a+++w++d[++++d

Try it Online!
I've finished my new language, called brainbox! It's a 2D extension of brainfuck, with a 2D grid for the code and a 2D grid for the memory. This program is a modification of the "Hello World!" program in brainfuck found on esolangs.org. I used a few features to shorten it:

Instead of using ++++++++ to set the first cell to 8, I used ++++<, which is 3 bytes shorter and changes the IP direction to the left.

I made use of the 2D memory space in order to reduce the number of commands needed to move the memory pointer around.

I also used an unmatched ] to loop execution back to (0,0). This doesn't actually save any bytes here, but I wanted to show off that feature.

For more information on the language and some of the features and quirks, check out the GitHub repo.

GForth 17 Bytes
." Hello, World!"

@Razetime Consensus is irrelevant since it works in the specific implementation.

@Razetime I would not call that a consensus.  If there is a disagreement it would be better to take this to the meta, than to discuss in comments.

abcn, 92 bytes
aaaac018gxnaaaaac020agxaaaaaaagxgxaaagxnaaaac008gxbbc004bgxbbbbbbbbgxaaagxbbbbbbgxbbbbbbbbgx

Obviously not the shortest answer by a mile but for me its fine.
Now how does this work
aaaac018gxn  H --> 72
aaaaac020agx E --> 101
aaaaaaagx    L --> 108
gx           L --> 108
aaagxn       O --> 111
aaaac008gx   SPACE ---> 32
bbc004bgx    W  --> 119
bbbbbbbbgx   O  --> 111
aaagx        R  --> 114
bbbbbbgx     L  --> 108
bbbbbbbbgx   D  --> 100

For reference a inc accumulator by 1, b decs by 1 and c is for multiplication
g converts to ASCII and x prints
(I do have an interpreter, clicking the link leads to it but you are gonna have to test it yourself)
NOTE : language is WIP

Paradoc, 15 bytes
first paradoc solution lol
"Hello, World!"

Try it online!

Jealous, 14 bytes
ᐗHello, World!

Noxan, 16 bytes
¶"Hello, World!

Noxan, 15 bytes
"Hello, World!"

Noxan, 14 bytes
"Hello, World!

Noxan, 2 bytes
¶g

Noxan, 1 bytes
g

New language!

No implicit output? Also, Noxan!

@lyxal I'll update this when I add implicit output.

Also, maybe add an alternative solution below with g

Exceptionally, 17 bytes
P"Hello, World!"/

Attempt This Online!
Explanation
P "Hello, World!"  ' Print that string
/                  ' Divide the register (initially 0) by itself to exit the program

SPDT, 756 bytes
p 0
r 0 0 1 2
r 1 0 2 3
r 4 0 2 3
r 3 0 2 5
r 5 0 2 6
r 6 0 2 7
r 7 0 2 8
r 8 0 2 9
r 9 0 2 10
r 10 0 2 11
r 11 0 2 12
r 12 0 2 13
r 13 0 2 14
r 14 0 2 15
r 15 0 2 4
r 5 0 2 16
r 8 0 2 16
r 11 0 2 16
r 12 0 2 16
r 4 0 2 16
r 8 0 2 17
r 11 0 2 17
r 12 0 2 17
r 13 0 2 17
r 5 0 2 18
r 6 0 2 18
r 7 0 2 18
r 8 0 2 18
r 9 0 2 18
r 11 0 2 18
r 12 0 2 18
r 14 0 2 18
r 15 0 2 18
r 3 0 2 19
r 6 0 2 19
r 7 0 2 19
r 8 0 2 19
r 9 0 2 19
r 12 0 2 19
r 14 0 2 19
r 11 0 2 20
r 13 0 2 20
r 5 0 2 21
r 6 0 2 21
r 7 0 2 21
r 8 0 2 21
r 9 0 2 21
r 10 0 2 21
r 12 0 2 21
r 13 0 2 21
r 14 0 2 21
r 15 0 2 21
r 4 0 2 21
r 3 0 2 22
r 5 0 2 22
r 6 0 2 22
r 7 0 2 22
r 8 0 2 22
r 11 0 2 22
r 12 0 2 22
r 13 0 2 22
r 14 0 2 22
r 15 0 2 22
l 23
l 22
l 21
l 20
l 19
l 18
l 17
l 16

Try it: https://radvylfprograms.com/spdt

SPDT is an esolang I've been wanting to make for a while now. Aside from I/O, it consists entirely of Single Pole Double Throw, or Form C, relays. This answer, which is possibly imperfectly golfed since I used a custom transpiler with macros to generate it, consists of relays forming a loop counting from 1 to 13, then back 1, infinitely. For each of these states, it uses relays to only light up the bits which are on in that character of Hello, World!, producing the following output:

ABC, 21 bytes
WRITE "Hello, World!"

Try it online!

CATHY, 175 bytes
catHYcAthycAthYcAthYcaTHycathycAthYcAthYcAthycatHycaTHycaThYcaTHycathYcatHycatHYcaTHycaTHYcAthycathYcatHycatHYcatHycatHYcatHYcatHYcatHYCatHycathYcathYcaThYCAthyCATHycATHycAtHy

Try it Online! -90 thanks to Steffan.
CATHY is a joke language based on a certain spam post. In normal form:
389960998265612367812323333;115τCƒ+

It pushes a huge integer, then converts to base 115 and charcodifies.

170 bytes

Verbosity v2, 87 bytes
For some reasons, at least in the TIO's implementation it doesn't require the import statements...
outpt=OutputSystem:NewOutput<DEFAULT>
OutputSystem:DisplayAsText<outpt;"Hello, World!">

Try it Online!
Note: the name outpt is because variables name must be at least 5 characters long.

Aheui (esotope), 92 bytes
붊볼벎봆뱞벽뱖벽브벓벍
부볃붊벋볾뱛벋따드먛뗘벎희별
밤뵗뵏뵒볾

Try it online!
Same code as below, but reuses four "data" chars (12 bytes) at the expense of two newlines. The compound vowel ㅚ does not have an assigned momentum, so the IP keeps going with the same speed and direction.

Aheui (esotope), 117 102 bytes
밞바밤밣받밞밞밞밦밞바밝밣바박박밦밞받밞받밞발밣받뱔희밞땨몋드떠받볋

Try it online!
Another approach that is simpler and actually achieves the 2-char-per-output encoding. Each byte in Hello, World! can be encoded as \$9x+y+24\$ where \$x, y \in \{0,2,3,4,5,6,7,8,9\}\$. Here is the encoder. It also happened that the two additions were neatly merged into one character (once with +2 step and the other with -1), shaving off another char.

Aheui (esotope), 117 bytes
박밤밝발밞받밝밝밦밞밦발받박타받발따발밯밦밞밞받밞받밤받발따밞뱧희밣댜몋땨뎌벎

Try it online!
Aheui (esotope), 123 bytes
박박발타밝받발밞밝발밣받밣바받받밣타받밯밣받발밞발밞밦발밝뱧희밣댜몋땨뎌뱔텨뱔벽떠

Try it online!
Previous record: 144 by Sait2000
Since Aheui cannot push 10 or higher number at once, these programs try to minimize the cost of data by encoding each character into two numbers on the stack. If we subtract each character's charcode by 9 (the magic number), we get
63 92 99 99 102 35 23 78 102 105 99 91 24
7x9, 23x4, 11x9, 11x9, 17x6, 7x5, 23x1, 13x6, 17x6, 15x7, 11x9, 13x7, 12x2

And then subtract 8 from the larger number of each pair to get
-1 9 15 4 3 9 3 9 9 6 -1 5 15 1 5 6 9 6 7 7 3 9 5 7 4 2

Each occurrence of 15 or 1 adds 3 commands; the rest can be pushed in one. Then the loop is essentially
loop {
  add 8 (if stack is empty, halt)
  mul
  add 9; print as char
}

The second program is written in the same way, but using 23 as the magic number instead.

Trilangle, 42 bytes
Prints no trailing newline.
"Hoo"!"o(oeooolo"""o"",Wr"!.looodo..o"""o@

Try it in the online interpreter: https://bbrk24.github.io/Trilangle/
The default program in the online interpreter is a variation on this that does print the trailing newline.

Logically, 1046 Bytes
@A:3i:o,c:4t;XOR(3i)(t3)AND(i0,i1)(t0)AND(i1,i2)(t1)AND(i0,i2)(t2)COPY(t3)(o)OR(3t)(c)
@B:8a,8b:8o,d:7c;A(a0,b0,0)(o0,c0)A(a1,b1,c0)(o1,c1)A(a2,b2,c1)(o2,c2)A(a3,b3,c2)(o3,c3)A(a4,b4,c3)(o4,c4)A(a5,b5,c4)(o5,c5)A(a6,b6,c5)(o6,c6)A(a7,b7,c6)(o7,d)
@C:i,a,b:d:x,y,z;NOT(i)(x)AND(a,x)(y)AND(b,i)(z)OR(y,z)(d)
@D:i,8a,8b:8o;C(i,a0,b0)(o0)C(i,a1,b1)(o1)C(i,a2,b2)(o2)C(i,a3,b3)(o3)C(i,a4,b4)(o4)C(i,a5,b5)(o5)C(i,a6,b6)(o6)C(i,a7,b7)(o7)
@E:1i,i,16a,16b:8o:8c,8d;D(1i,16a)(8c)D(1i,16b)(8d)D(i,8c,8d)(8o)
@F:2i,i,32a,32b:8o:8c,8d;E(2i,32a)(8c)E(2i,32b)(8d)D(i,8c,8d)(8o)
@G:3i,i,64a,64b:8o:8c,8d;F(3i,64a)(8c)F(3i,64b)(8d)D(i,8c,8d)(8o)
@H:i:p:b_HIGH;NOT(i)(b)AND(i,b)(p)
@I:i:o:16d;COPY(i,16d)(16d,o)
@J B:8a,8i,b,r,d,8c;B(8a,1)(8i)CELL(b,8i)(8a)H(H)(r)OR(r,b)(d)I(d)(b)WRITE(b,8c)()G(4a,0,0,0,1,0,0,1,0,1,0,1,0,0,1,1,0,0,0,1,1,0,1,1,0,0,0,1,1,0,1,1,0,1,1,1,1,0,1,1,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,1,0,1,0,1,1,1,1,0,1,1,0,0,1,0,0,1,1,1,0,0,0,1,1,0,1,1,0,0,0,1,0,0,1,1,0,1,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1)(8c)HALT(c7)()

Ungolfed
@2BitAdder
: 3in;
: out, carry;
: 4t;
XOR  (3in)           (t3)
AND  (in0, in1)      (t0)
AND  (in1, in2)      (t1)
AND  (in0, in2)      (t2)
COPY (t3)            (out)
OR   (3t)            (carry)

@ByteAdder
: 8a, 8b;
: 8o, carry;
: 7c;
2BitAdder (a0, b0, 0)  (o0, c0)
2BitAdder (a1, b1, c0) (o1, c1)
2BitAdder (a2, b2, c1) (o2, c2)
2BitAdder (a3, b3, c2) (o3, c3)
2BitAdder (a4, b4, c3) (o4, c4)
2BitAdder (a5, b5, c4) (o5, c5)
2BitAdder (a6, b6, c5) (o6, c6)
2BitAdder (a7, b7, c6) (o7, carry)

@Mux
: i, a, b;
: d;
: ni, ani, bi;
NOT (i)       (ni)
AND (a, ni)   (ani)
AND (b, i)    (bi)
OR  (ani, bi) (d)

@ByteMux
: i, [8d0], [8d1];
: [8o];
Mux (i, d00, d10) (o0)
Mux (i, d01, d11) (o1)
Mux (i, d02, d12) (o2)
Mux (i, d03, d13) (o3)
Mux (i, d04, d14) (o4)
Mux (i, d05, d15) (o5)
Mux (i, d06, d16) (o6)
Mux (i, d07, d17) (o7)

@4ByteMux
: 1i, i, 16a, 16b;
: 8o;
: 8c, 8d;
ByteMux (1i, 16a)    (8c)
ByteMux (1i, 16b)    (8d)
ByteMux ( i, 8c, 8d) (8o)

@8ByteMux
: 2i, i, 32a, 32b;
: 8o;
: 8c, 8d;
4ByteMux (2i, 32a)     (8c)
4ByteMux (2i, 32b)     (8d)
ByteMux  ( i, 8c,  8d) (8o)

@FByteMux
: 3i, i, 64a, 64b;
: 8o;
: 8c, 8d;
8ByteMux (3i, 64a)    (8c)
8ByteMux (3i, 64b)    (8d)
ByteMux  ( i, 8c, 8d) (8o)

@RisingEdge
: in;
: pulse;
: bar_HIGH;
NOT (in)      (bar)
AND (in, bar) (pulse)

@Delay
: in;
: out;
: 16d;
COPY (in, 16d) (16d, out)

@Main
Bus: 8a, 8i, clock, risingPulse, delayIn, 8c;
ByteAdder       (8a, 1) (8i)
CELL            (clock, 8i)             (8a)
RisingEdge      (H)                     (risingPulse)
OR              (risingPulse, clock)    (delayIn)
Delay           (delayIn)               (clock)
WRITE           (clock, [8c])           ()
FByteMux        (4a,
                0,0,0,1, 0,0,1,0,
                1,0,1,0, 0,1,1,0,
                0,0,1,1, 0,1,1,0,
                0,0,1,1, 0,1,1,0,
                1,1,1,1, 0,1,1,0,
                0,0,1,1, 0,1,0,0,
                0,0,0,0, 0,1,0,0,
                1,1,1,0, 1,0,1,0,
                1,1,1,1, 0,1,1,0,
                0,1,0,0, 1,1,1,0,
                0,0,1,1, 0,1,1,0,
                0,0,1,0, 0,1,1,0,
                1,0,0,0, 0,1,0,0,
                0,1,0,1, 0,0,0,0,
                0,0,0,0, 0,0,0,1)
                                        (8c)
HALT            (c7)                    ()

Uses a Clock circuit to count up and output each character manually from a 16 byte Demuxer

Java, 47 bytes
void main(){System.out.print("Hello, World!");}

This uses JEP 445: Unnamed Classes and Instance Main Methods which is released in Java 21 as a preview.
With the preview JDK, run like this:
java --source 21 --enable-preview Main.java

Nice. I just read about this in JEP 463. If it didn't have an answer yet, I would've made one.

D, 42 bytes
Something reminded me of this challenge today, so together with a few folks on the D Discord server, we devised what might be, however cursed, the shortest D hello world.
import std;@0main()=>"Hello, World!".puts;

Firstly, for some versions now, import std imports a large part of std modules including std.stdio, which saves 6 bytes from the usual solution. Secondly, we abuse AutoFuncDeclaration and User-Defined Attributes to apply a 0 literal as a function attribute, letting us omit the return type void. And, as it turns out, the D parser does not forbid placing identifiers right after numbers, letting us combine this into @0main. This might appear to be the devil's own creation but is 3 bytes shorter than the usual void main. Lastly, by using UFCS and substituting write or writeln for puts we save further 2 bytes.
We use the arrow notation for general "golfiness" but it's exactly the same length as if we had used braces, i.e. @0main(){...}
A questionable alternative, 38 bytes
pragma(msg,"Hello, World!");@0main(){}

While the program produced by this is valid, it doesn't do anything, and "Hello, World!" is printed during compilation.

I haven't been able to reproduce this. Could you provide a link on https://run.dlang.io ?

Uiua, 17 bytes
&p"Hello, World!"

Explanation:
&p"Hello, World!"
  "Hello, World!" # push our dear string to the stack
&p                # print with newline

Try it online!

Welcome to Code Golf SE! I'm surprised nobody posted this yet

Algoid, 28 bytes
text.output("Hello, World!")

Now that's just boring in such a fun language... Here's a slightly longer version, let's get some colours going for 104 bytes:
algo.hide()
algo.setColor(algo.color.GREEN)
algo.setBgColor(algo.color.DARK_RED)
algo.text("Hello, World!")

See the output here
Okay I've finished for the day now :)

Scheme, 24 26 25 bytes
(write "Hello, World!")
(display"Hello, World!")

simple but no one has done it in this language yet.
edit:
fixed the quotes being printed.

i changed the code a little so it doesn't show the quotes

Are the quote marks necessary in case of display? The H in Hello needs to be upper-case btw.

@CoDEmanX Yeah the quotes are necessary. Otherwise it thinks its a variable.

Sure you can't get rid of the space before "?

That space can be removed. Normally scheme needs the spaces to tell two things apart. but in this case it doesn't need it

Io, 21 bytes
"Hello, World!" write

This Io (TIO) seems to have print, but not write. Is this another language with the same name?

@Dennis It appears to have write, but it appears to write to some mysterious location/file/somewhere else instead of STDOUT

Common LISP, 22 bytes
(princ"Hello, World!")

Burlesque, 17 bytes
,"Hello, World!"Q

The leading , tells Burlesque to ignore standard input. "Hello, World!" pushes a string to the stack, and Q formats it for display without quotes.

Yes, otherwise Burlesque will add "".

Sure, that works just as well! The , primitive (it's sort of like a flag, I guess?) is there for historic reasons; Q is a new-ish synonym for sh which was longer.

RPython, 60 bytes
def e():print'Hello, World!';return 0
target=lambda*_:e,None

awk, 25 bytes
END{print"Hello, World!"}

I know little of awk, but I think you can remove the END part. (It's June I know).

Actually, if you use END, it requires some kind of input... the input can be empty but it seems to be needed on my version of AWK.  You do need a label, though, otherwise nothing will happen.  BEGIN works, but it adds 2 bytes. :(

You're both right(ish). If you can invoke the one blank line of input rule you don't need the END, otherwise you must use BEGIN not END.

If the one-blank-input rule is allowed, this works too $0="Hello World!"

Erlang, 63 bytes
Save as h.erl, then compile with erl -s h m, I think.
-module h.
-export[m/0].
m()->io:fwrite("Hello, World!").

Mathematica, 21 bytes
Print@"Hello, World!"

Mathemaica 10.3, 20 bytes
Echo@"Hello, World!"

Feel free to count the 10.3 version as the main solution and include the older one for reference.

23, 52 bytes
17,13,72,101,108,108,111,44,32,87,111,114,108,100,33

This uses 23.dezsy notation: 17,13 prints the 13 integers that follow as characters.
Try it online here. (Don't forget to replace the example with the above source code.)

Glypho, 480 bytes
In the "shorthand" format, it's 120 bytes:
1d+d1+d*+ddd++ddd++1+d11+d*d++d11+1+d++d1-dd+++d1<d>+-d++11+d*d*d+<d>d+d+d<d>+d+1+d1-dd+++d1-<d>+d*1+11+1+d+d*d+<d-+>[o]

An example conversion to "true" Glypho (using the translation of the Java interpreter, which differs slightly from that documented in the esolangs.org page) is:
v># #  :: < <   <v#  #*>*> ##:#**#,<,<: : > > *  *v>>v # ##,#, + +:++: ++ ##
*<<*,^,^<<#v<<v#v::v< < <,, +,+,+>>+*,,*+*+*,,*>**^v#  #,,:^#vv#>+>+ << >  >, , ++*>:
:v<v<^#^#v::v>::>v**v # #::>^>+>>:>:>>>*>>##>*^ *# #  vv ,::,<<>:++
*vv*v:v:^vv< > > ,,>>:>: << >+>>^ ^ ^^*^+,+,#::#*:*::  :v v  ,   # #<<#<#**#^,^,+##+**
+**+,:,:::>*<^v< v v+^+^*^^*+<<++##+v#v#++<>:< :* **+ +   ^ *  *<+<+<  *vv+<:^^:::
^+*<<***<^+  ++:+:^##^:>:>+::< > >#>># *  >,>, :^ ^>>^##<#,<,*^   *<:<

(using Windows line terminators \r\n) where I tried to disguise it as a 2D language for the Programming Language Quiz.
The basic approach is to push onto the stack a 0 followed by the codepoints in reverse order, and then print them with the loop [o]. In order to golf the pushing, I first push 11 and then I can push a new 11 whenever I want with <d>; the final <d-+> replaces that 11 on the bottom of the stack with the desired 0.
I experimented with various values on the bottom of the stack, and 11 is the only one for which my brute-force searcher was able to find expressions for each of the characters which were no more than 11 bytes each. (12 bytes was taking too long).

Quick translation from my CSL answer (i.e. super suboptimal), 456

Maxima, 23 bytes
print("Hello, World!")$

UNBABTIZED
:72.:101.:108.:108.:111.:44.:32.:87.:111.:114.:108.:100.:33

:x prints x as a character and . acts as a statement separator.
The official interpreter is written for Python 2.2. You can use it in modern versions of Python by prepending the line
# coding: latin1

Parenthetic, 1036 Bytes
This can undoubtedly be done better, but it's about the best I can come up with at the moment.
((()()())(()()()())((()()(()))((())()()()())((())()()()()()()()())))((()()())(()(())())((()(()))(()()()())((())()()()())))((()()())(()()(()()))((()()(()))(()()()())((())()()())))((()()())(()(()())())((()()(()))(()(())())((())()()())))((()(())()(()))((()((()))())((()(())(())())((()()(()))(()(())())((())()())))((()((()))())((()(())(())())((()(()))(()()(()()))((())()()()()())))((()((()))())((()(())(())())(()(()())()))((()((()))())((()(())(())())(()(()())()))((()((()))())((()(())(())())((()(()))(()(()())())((())()()())))((()((()))())((()(())(())())((()(()))(()()()())((())()()()()()()()()()()()())))((()((()))())((()(())(())())(()()()()))((()((()))())((()(())(())())((()(()()))(()()(()()))((())()()()()()()()()())))((()((()))())((()(())(())())((()(()))(()(()())())((())()()())))((()((()))())((()(())(())())((()(()))(()(()())())((())()()()()()())))((()((()))())((()(())(())())(()(()())()))((()((()))())((()(())(())())((()(()))(()()(()()))((())()()()())))((()((()))())((()(())(())())((()(()))(()()()())((())())))(()((())))))))))))))))))

General Steps

Define A 32
Define B 36
Define C 32 * 3
Define D 36 * 3
Build a list of chars with (A*2)(C+5)(D)(D)(D+3)(A+12)(A)(C-9)(D+3)(D+6)(D)(C+4)(A+1)
Output list + empty set as string

l33t, 104 bytes
7 99999998 1 7 9991 1 7 6 1 1 7 2 1 5 0 7 99997 1 8 92 1 6 0 8 995 1 7 995 1 7 2 1 8 5 1 8 7 1 5 0 7 0 1

I've been using the Ruby interpreter which seems to insert an 10 (END) at the end of the code implicitly.
l33t is supposed to look like l33t-5p34k. However, it is interpreted by simply summing the digits in each "word" and turning that into an opcode. So for golfing all we want is those digits. Golfing l33t like this is definitely living on the edge though. Quoting from the language spec:

It is possible to program in l33t just using numbers, i.e. not forming letters in l33t 5p34k. However, programmers who do this are teh sUxX0r, and the interpreter is well within its rights to format your hard drive for attempting this.

As for the language itself, it's basically a Brainfuck-derivative. The main differences are that the source code is living on the tape as well (with an independent memory and instruction pointer), and that you define an offset whenever you move forward, backward, increment or decrement (so you can make larger jumps and increment more efficiently). Therefore, the techniques used in the short Brainfuck solutions don't help much here.
I started out with the naive solution (increment/decrement to value, print, repeat). That was 105 bytes. I managed to shave off one byte by computing the symbols , ! on a different memory cell than the letters (because the offsets from o to ,, space to W and d to ! are expensive. I think I might be able to save a few more by jumping into the program memory, but I'll have to try that tomorrow.

Wake, 16 bytes
:"Hello, World!"

Not much room for golfing.

ShortScript, 2 bytes
By using the function from the standard library:
$H

And by not using it:
→Hello, World!

That library seems to be missing from your reference implementation on Esolang.

Yes, I the current version is a bit buggy

I have updated the esolangs page. Now it will work.

That implementation doesn't seem to print the exclamation point.

I will fix it tomorrow, when I am at PC.

I have fixed it.

Sieve, 69 bytes
+|72|.+|101|.+|108|..>+|111|.>+|44|.-|32|.+|87|.<.+++.<.-|100|.-|33|.

Sieve is a BF-like programming language. It adds a special command |X|, called a sieve, that executes the command before it until the selected tape unit is equal to the number within the sieve. +|72|. outputs the character 72, which is an "H".
Here's an alternative with the same byte count:
+|72|.+|101|.+|108|..>+|111|.>+|44|.-|32|.>+|87|.<<.+++.<.-|100|.>>+.

The only change is that it saves 32 (space) and uses it later to print 33 (!).

Can you save some bytes by leaving the cell of the space untouched for World and then going back to it to print ! with a simple +.?

@MartinBüttner Yes, oops.

@MartinBüttner Actually, the byte count is the same.

+|72|.+|101|.>+|108|..>+|111|.>+|44|.-|32|.+|87|.<.+++.<.<-.-|33|. for 66

@Sp3000 Welp, already getting my butt kicked at my own language.

Ceylon, 40 bytes (or 24)
A file with this content can be executed in the Ceylon IDE:
shared void h(){print("Hello, World!");}

As Ceylon has no "top-level procedural code", all code needs to be either in a class or in a function. And only shared functions/classes can be called from outside ... and the IDE will chose the only shared function or class, if there is only one.
The Ceylon Web runner seems not to accept that text (it complains that "shared declaration is not a member of a class, interface, or package"), but instead allows directly statements:
print("Hello, World!");

(I guess the entered text is automatically wrapped in a function, and you can't declare stuff inside a function shared.)

HPPPL, 44 43 bytes
HP Prime Programming Language for the HP Prime color graphing calculator.
export h()begin print("Hello, World!");end;

(golfed down by one byte, thanks to kirbyfan64sos!)
Output:

This is a full program that you call by entering h to start it.
If you just want to have the output to the terminal, then a shorter (22 bytes) version in Home Mode works, too:
print("Hello, World!")

A free emulator is available here: http://www.hp-prime.de/en/category/13-emulator

Is the space between the right parenthesis and begin needed?

@kirbyfan64sos Thanks for the hint. No, it’s not necessary.

az, 16 bytes
"Hello, World!".

TRANSCRIPT, 36 bytes
He is here.
>HE, Hello, World!
>X HE

The second line sets HE, and the third line outputs it.

I was initially going to post this, but for some reason I kept getting errors whenever I tried to use single-char NPC names...

@Sp3000 You're right, I just looked at the interpreter and found that it only matches two-letter words or longer.

@LegionMammal978 You should use He.

Cardinal, 15 bytes
%"Hello, World!

LMNtal, 35 bytes
io.use.io.print("Hello, World!",_).

A weird programming language from Japan that seems to be inspired by Prolog.

RUBE, 47 bytes
A cellular automaton-based language about warehouses, crates, dozers, and conveyor belts:
2
1
766
2c4
256
07f
662
cfc
466
85c
OOO
ccc
===

It turns out stacking all the crates on top of each other like 2\n1\n6\n... is also 57 bytes, and is "simpler", but I didn't want to stretch the page. :)
Update: stacking the crates into a rectangle is shorter! Who'd've thought?

Fishing, 37 bytes
v+CCCCCCCCCCCCCCCC
  `Hello, World!`N

I don't think there's anything to golf beyond the example listed on the esolangs page, so I didn't really write this myself. Hence, community wiki.

Doorspace, 92 bytes
The language is also known as Qugord.
~group h from %2 to %14 affect h into "Hello, World!" each h into 0 task give 0 to 1 publish

or
~group h from 0 to %12 affect h into "Hello, World!" each h into 0 task give 0 to %0 publish

It's seriously bugging me that this has a horizontal scrollbar because of a single character. I don't see how to shorten it any further though.
This solution is mostly a golfed version of the "Hello, World!" example on the esolangs page. The important concepts of the language are that it operates on an infinite main array, initialised to zeroes; and then there's also an output array, which is reset every time you print its contents. If you know what the commands mean, the code is actually quite readable if split across several lines (which is not valid in the language):
group h from %2 to %14
affect h into "Hello, World!"
each h into 0 task
  give 0 to 1
  publish

The first line defines a "group tag" h, which is some subarray of the main array. In this case, it addresses the cells at indices 2 to 14 (leaving 2 cells for future use).
The second line writes the character codes of Hello, World! into these 13 cells.
The third line defines a foreach loop over the cells in h, which works by copying the current value into the specified cell (0) and then executing the code after it.
The fourth line is executed once for each character code (which we find in cell 0). It moves the character code from the 0th cell of the main array to the 0th cell of the output array (which we index relatively by looking at index 1 on the main tape, which is zero).
The fifth line prints everything in the output array up to the last non-zero element (i.e. just the first cell in our case).

Hodor, 66 bytes
hodor.hod("Hhodor? Hodor!? Hodor!? o, Hooodorrhodor orHodor!? d!")

This only works in the previous version of Hodor (the one before the update from 1 July 2015). The latest version prints HODOR instead, which could be fixed at the cost of 3 bytes:
hodor.hod("Hhodor? Hodor!? Hodor!? o, Hooodorrhodor orHodor!? "+"d!")

Monkeys, 505 bytes
6 DOWN
6 DOWN
7 RIGHT
7 RIGHT
6 LEFT
5 DOWN
5 DOWN
5 DOWN
7 BOND
6 BOND
6 BOND
7 YELL
7 DOWN
6 DOWN
6 BOND
7 LEFT
6 LEFT
7 YELL
7 LEFT
7 LEFT
6 BOND
6 LEFT
6 LEFT
7 YELL
7 YELL
6 LEFT
6 LEFT
6 LEFT
7 YELL
5 BOND
7 LEFT
7 YELL
6 LEFT
6 LEFT
6 LEFT
6 LEFT
5 BOND
7 YELL
7 DOWN
7 DOWN
7 DOWN
5 DOWN
5 DOWN
5 DOWN
5 BOND
7 YELL
6 LEFT
7 DOWN
6 BOND
7 DOWN
7 YELL
7 LEFT
7 LEFT
7 LEFT
7 YELL
7 LEFT
6 LEFT
5 BOND
5 BOND
5 BOND
7 YELL
7 LEFT
6 DOWN
6 DOWN
6 BOND
7 LEFT
7 YELL
7 LEFT
6 DOWN
6 DOWN
6 BOND
7 YELL

I wanted to post this one for a while, but the interpreter had several bugs. However, David Catt (the author) was kind enough to upload a new, working interpreter, so I got to work...
I have no idea how to golf this language effectively, because there are so many things which are interacting. My basic approach was this:

Move monkeys 5, 6 and 7 to the bottom row, like this:
..!1.!....
.......2!.
.........!
.3.!......
.......!..
.!....!...
....!4....
........!.
......!...
..576...!.

At this point they have values 1, 1, 2.
This gives me comparably flexible operations: I can increment 5 and 7, or 7 and 6. I can decrement each one individually. And I can multiply 7 by the value of either 5 or 6 (mod 256).
So I just wrote a simple Mathematica program to look into short ways to get 7 to the next value via a few multiplications and de/increments. This search was not exhaustive, but provided much better results than naively incrementing/decrementing to the next value.

There are many more opportunities to golf this though:

One can use the other arithmetic operators, particularly addition and subtraction could be useful.
I'm always using 7 for printing - allowing 5 or 6 to print (or involving even more monkeys) might shorten things.
One could try to store some useful values like 111 or 32 in a monkey for later use.
Arrange the monkeys vertically, so that one could use UP instead of LEFT.
Maybe this can even be shortened with loops.

...but the language is so complicated that I'm not sure how to explore these possibilities systematically.

Symball, 47 bytes
'0H'0e'0l'0l'0o*59$-$1$'1$'0_'0W'0o'0r'0l'0d'1-

Try it here. (dead link)

The link is dead.

That's unfortunate. I've replaced the link at the top with a link to the Esolang page, but unless the website comes back, there are no docs and no interpreter...

C#, 67 Bytes
class a{static void Main(){System.Console.Write("Hello, World!");}}

This has been posted before

I missed it.  Sorry.

Axo, 29 bytes
"!dlroW ,o%
\%#[<"Hell<
 >( ^

Please let me know if this can be golfed further.

Another 29 byte solution: "!dlroW ,olleH"(((((((((((((\

You may want to consider putting in a TIO link to make it more accessible for others to test it

On the first line, the comma should be after the space, as currently this outputs "Hello ,World!" rather than "Hello, World!"

@Jacob Good catch, thank you!

Minkolang 0.1, 18 bytes
"Hello world!"(O).

"Hello world!" is pushed onto the stack in reverse order (by Minkolang), then (O) repeatedly prints the top of stack (as it's a while loop) until it's empty, at which point the program counter proceeds to . and terminates.

From the explanation, it sounds like the parentheses can be dropped. But correct me if I'm wrong.

@SuperJedi224: The parentheses are the while loop. The O outputs the top of stack as a character.

But I think you can just do that once without the loop.

@SuperJedi224: It would only output "H".

Oh, so it pushes the individual characters and not the entire string at once. Thanks for explaining that for me.

@SuperJedi224: Right. Minkolang (well, really, the Python interpreter) flips the string around before pushing the characters onto the stack for the programmer's convenience. Number literals, however, are pushed as one number.

BotEngine, 2x15=30
vHello, World!
>eeeeeeeeeeeeeP

Ouroboros, 27
S"Hello, World!"1(
13wSoL!(

The program consists of two lines of code, each of which represents an ouroboros snake.
Snake 1
S sets the snake's active stack to the shared stack. The string literal pushes the character codes of Hello, World! in reverse order. Finally, 1( causes the snake to swallow the last character of its tail. Since this is the instruction that the IP is currently on, the snake dies.
Snake 2
13w causes the snake to wait for 13 ticks (so snake 1 can finish pushing the string). S switches to the shared stack and o outputs a character. L! pushes the length of the shared stack and logically negates it, resulting in 1 if the stack is empty and 0 if not. ( swallows that many characters of the snake's tail. If the stack is not yet empty, nothing is swallowed, and control loops back to the head of the snake, where it waits a while, sets the active stack as the shared stack, and outputs the next character. Once all the characters have been output, L! gives 1, and the snake swallows its IP and dies.
See it in action via Stack Snippet:

// Define Stack class
function Stack() {
  this.stack = [];
  this.length = 0;
}
Stack.prototype.push = function(item) {
  this.stack.push(item);
  this.length++;
}
Stack.prototype.pop = function() {
  var result = 0;
  if (this.length > 0) {
    result = this.stack.pop();
    this.length--;
  }
  return result;
}
Stack.prototype.top = function() {
  var result = 0;
  if (this.length > 0) {
    result = this.stack[this.length - 1];
  }
  return result;
}
Stack.prototype.toString = function() {
    return "" + this.stack;
  }

// Define Snake class
function Snake(code) {
  this.code = code;
  this.length = this.code.length;
  this.ip = 0;
  this.ownStack = new Stack();
  this.currStack = this.ownStack;
  this.alive = true;
  this.wait = 0;
  this.partialString = this.partialNumber = null;
}
Snake.prototype.step = function() {
    if (!this.alive) {
      return null;
    }
    if (this.wait > 0) {
      this.wait--;
      return null;
    }
    var instruction = this.code.charAt(this.ip);
    var output = null;
    if (this.partialString !== null) {
      // We're in the middle of a double-quoted string
      if (instruction == '"') {
        // Close the string and push its character codes in reverse order
        for (var i = this.partialString.length - 1; i >= 0; i--) {
          this.currStack.push(this.partialString.charCodeAt(i));
        }
        this.partialString = null;
      } else {
        this.partialString += instruction;
      }
    } else if (instruction == '"') {
      this.partialString = "";
    } else if ("0" <= instruction && instruction <= "9") {
      if (this.partialNumber !== null) {
        this.partialNumber = this.partialNumber + instruction; // NB: concatenation!
      } else {
        this.partialNumber = instruction;
      }
      next = this.code.charAt((this.ip + 1) % this.length);
      if (next < "0" || "9" < next) {
        // Next instruction is non-numeric, so end number and push it
        this.currStack.push(+this.partialNumber);
        this.partialNumber = null;
      }
    } else if ("a" <= instruction && instruction <= "f") {
      // a-f push numbers 10 through 15
      var value = instruction.charCodeAt(0) - 87;
      this.currStack.push(value);
    } else if (instruction == "$") {
      // Toggle the current stack
      if (this.currStack === this.ownStack) {
        this.currStack = this.program.sharedStack;
      } else {
        this.currStack = this.ownStack;
      }
    } else if (instruction == "s") {
      this.currStack = this.ownStack;
    } else if (instruction == "S") {
      this.currStack = this.program.sharedStack;
    } else if (instruction == "l") {
      this.currStack.push(this.ownStack.length);
    } else if (instruction == "L") {
      this.currStack.push(this.program.sharedStack.length);
    } else if (instruction == ".") {
      var item = this.currStack.pop();
      this.currStack.push(item);
      this.currStack.push(item);
    } else if (instruction == "m") {
      var item = this.ownStack.pop();
      this.program.sharedStack.push(item);
    } else if (instruction == "M") {
      var item = this.program.sharedStack.pop();
      this.ownStack.push(item);
    } else if (instruction == "y") {
      var item = this.ownStack.top();
      this.program.sharedStack.push(item);
    } else if (instruction == "Y") {
      var item = this.program.sharedStack.top();
      this.ownStack.push(item);
    } else if (instruction == "\\") {
      var top = this.currStack.pop();
      var next = this.currStack.pop()
      this.currStack.push(top);
      this.currStack.push(next);
    } else if (instruction == "@") {
      var c = this.currStack.pop();
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(c);
      this.currStack.push(a);
      this.currStack.push(b);
    } else if (instruction == ";") {
      this.currStack.pop();
    } else if (instruction == "+") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a + b);
    } else if (instruction == "-") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a - b);
    } else if (instruction == "*") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a * b);
    } else if (instruction == "/") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a / b);
    } else if (instruction == "%") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a % b);
    } else if (instruction == "_") {
      this.currStack.push(-this.currStack.pop());
    } else if (instruction == "I") {
      var value = this.currStack.pop();
      if (value < 0) {
        this.currStack.push(Math.ceil(value));
      } else {
        this.currStack.push(Math.floor(value));
      }
    } else if (instruction == ">") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a > b));
    } else if (instruction == "<") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a < b));
    } else if (instruction == "=") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a == b));
    } else if (instruction == "!") {
      this.currStack.push(+!this.currStack.pop());
    } else if (instruction == "?") {
      this.currStack.push(Math.random());
    } else if (instruction == "n") {
      output = "" + this.currStack.pop();
    } else if (instruction == "o") {
      output = String.fromCharCode(this.currStack.pop());
    } else if (instruction == "r") {
      var input = this.program.io.getNumber();
      this.currStack.push(input);
    } else if (instruction == "i") {
      var input = this.program.io.getChar();
      this.currStack.push(input);
    } else if (instruction == "(") {
      this.length -= Math.floor(this.currStack.pop());
      this.length = Math.max(this.length, 0);
    } else if (instruction == ")") {
      this.length += Math.floor(this.currStack.pop());
      this.length = Math.min(this.length, this.code.length);
    } else if (instruction == "w") {
      this.wait = this.currStack.pop();
    }
    // Any instruction not covered by the above cases is ignored
    if (this.ip >= this.length) {
      // We've swallowed the IP, so this snake dies
      this.alive = false;
      this.program.snakesLiving--;
    } else {
      // Increment IP and loop if appropriate
      this.ip = (this.ip + 1) % this.length;
    }
    return output;
  }

// Define Program class
function Program(source, speed, io) {
  this.sharedStack = new Stack();
  this.snakes = source.split(/\r?\n/).map(function(snakeCode) {
    var snake = new Snake(snakeCode);
    snake.program = this;
    snake.sharedStack = this.sharedStack;
    return snake;
  }.bind(this));
  this.snakesLiving = this.snakes.length;
  this.io = io;
  this.speed = speed || 10;
  this.halting = false;
}
Program.prototype.run = function() {
  if (this.snakesLiving) {
    this.step();
    this.timeout = window.setTimeout(this.run.bind(this), 1000 / this.speed);
  }
}
Program.prototype.step = function() {
  for (var s = 0; s < this.snakes.length; s++) {
    var output = this.snakes[s].step();
    if (output) {
      this.io.print(output);
    }
  }
}
Program.prototype.halt = function() {
  window.clearTimeout(this.timeout);
}
var ioFunctions = {
  print: function(item) {
    var stdout = document.getElementById('stdout');
    stdout.value += "" + item;
  },
  getChar: function() {
    if (inputData) {
      var inputChar = inputData[0];
      inputData = inputData.slice(1);
      return inputChar.charCodeAt(0);
    } else {
      return -1;
    }
  },
  getNumber: function() {
    while (inputData && (inputData[0] < "0" || "9" < inputData[0])) {
      inputData = inputData.slice(1);
    }
    if (inputData) {
      var inputNumber = inputData.match(/\d+/)[0];
      inputData = inputData.slice(inputNumber.length);
      return +inputNumber;
    } else {
      return -1;
    }
  }
};
var program = null;
var inputData = null;

function resetProgram() {
  var stdout = document.getElementById('stdout');
  stdout.value = null;
  if (program !== null) {
    program.halt();
  }
  program = null;
  inputData = null;
}

function initProgram() {
  var source = document.getElementById('source'),
    stepsPerSecond = document.getElementById('steps-per-second'),
    stdin = document.getElementById('stdin');
  program = new Program(source.value, +stepsPerSecond.innerHTML, ioFunctions);
  inputData = stdin.value;
}

function runBtnClick() {
  if (program === null || program.snakesLiving == 0) {
    resetProgram();
    initProgram();
  } else {
    program.halt();
    var stepsPerSecond = document.getElementById('steps-per-second');
    program.speed = +stepsPerSecond.innerHTML;
  }
  program.run();
}

function stepBtnClick() {
  if (program === null) {
    initProgram();
  } else {
    program.halt();
  }
  program.step();
}
.container {
  width: 100%;
  padding: 6px 0;
}
.so-box {
  font-family: 'Helvetica Neue', Arial, sans-serif;
  font-weight: bold;
  color: #fff;
  text-align: center;
  padding: .3em .7em;
  font-size: 1em;
  line-height: 1.1;
  border: 1px solid #c47b07;
  -webkit-box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
  text-shadow: 0 0 2px rgba(0, 0, 0, 0.5);
  background: #f88912;
  box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
}
.control {
  display: inline-block;
  border-radius: 6px;
  float: left;
  margin-right: 25px;
  cursor: pointer;
}
.option {
  padding: 10px 20px;
  margin-right: 25px;
  float: left;
}
h1 {
  text-align: center;
  font-family: Georgia, 'Times New Roman', serif;
}
a {
  text-decoration: none;
}
input,
textarea {
  box-sizing: border-box;
}
textarea {
  display: block;
  white-space: pre;
  overflow: auto;
  height: 40px;
  width: 100%;
  max-width: 100%;
  min-height: 25px;
}
span[contenteditable] {
  padding: 2px 6px;
  background: #cc7801;
  color: #fff;
}
#stdout-container,
#stdin-container {
  height: auto;
}
#stdin-container {
  display: none;
}
#reset {
  float: right;
}
#source-display-wrapper {
  display: none;
  width: 100%;
  height: 100%;
  overflow: auto;
  border: 1px solid black;
  box-sizing: border-box;
}
#source-display {
  font-family: monospace;
  white-space: pre;
  padding: 2px;
}
.activeToken {
  background: #f88912;
}
.clearfix:after {
  content: ".";
  display: block;
  height: 0;
  clear: both;
  visibility: hidden;
}
.clearfix {
  display: inline-block;
}
* html .clearfix {
  height: 1%;
}
.clearfix {
  display: block;
}

  <textarea id="source" placeholder="Enter your program here" wrap="off">S"Hello, World!"1(
13wSoL!(</textarea>

  <textarea id="stdin" placeholder="Input" wrap="off"></textarea>

  <input type="button" id="run" class="control so-box" value="Run" onclick="runBtnClick()" />
  <input type="button" id="pause" class="control so-box" value="Pause" onclick="program.halt()" />
  <input type="button" id="step" class="control so-box" value="Step" onclick="stepBtnClick()" />
  <input type="button" id="reset" class="control so-box" value="Reset" onclick="resetProgram()" />

  <textarea id="stdout" placeholder="Output" wrap="off" readonly></textarea>

Steps per Second: 100

AniRad, 237 bytes
I doubt if this is the shortest solution:
 # # #   # # # #
#5+7*3      *2  =C
 / * +       *
#9*9+9+5+6      =C
   + *   +
#> 9*9+1+9  +9+8=C
   +     +   * *
#^ 9     > 4*6  =C
     +     *
#9+1*9+9+5+3  +4=C
   + -     * - +
#  6-6  +4*9+8 1=C
   = =     = = =
   C C     C C C

This is a 2D esolang which looks a bit like a magic square. This is a very early stage of the language, so a lot of new functions etc. will come in the future.
The # is the starting point of the pointer. The interpreter goes through every starting point. The order is based on the position of the #:
   4 5 6 7
   # # # #
1 #

2 #

3 #

If the position of the starting point is on the left, the pointer direction is right. If the position of the starting point is on the top, the pointer direction is down.
The +, -, * and / are just basic math operators. After reading a number from the pointer, every other number on it's path will be ignored until an operation has been executed, e.g. #4+3 5-2= is equivalent to #4+3-2=
The direction of the pointer can be changed with >, ^, < and v
To output a char, we use the =C. This outputs the result of all the math operators and converts the int to a char. If = is used, the interpreter will only print the result.
Here are all the paths executed in the program:
(1)  5+7*3*2           = (((5+7)*3)*2)            = 72  = H
(2)  9*9+9+5+6         = ((((9*9)+9)+5)+6)        = 101 = e
(3)  9*9+1+9+9+8       = (((((9*9)+1)+9)+9)+8)    = 108 = l
(4)  9*9+1+9+9+8       = (((((9*9)+1)+9)+9)+8)    = 108 = l
(5)  9+1*9+9+5+3+4     = (((((9+1)*9)+9)+5)+3)+4) = 111 = o
(6)  6-6+4*9+8         = ((((6-6)+4)*9)+8)        = 44  = ,
(7)  5/9*9+1+9+9+8     = ((((((5/9)*9)+1)+9)+9)+8)= 32  =
(8)  7*9+9+9+6         = ((((7*9)+9)+9)+6)        = 87  = W
(9)  3+9*9+9-6         = ((((3+9)*9)+9)-6)        = 111 = o
(10) 6+9+4*6           = (((6+9)+4)*6)            = 114 = r
(11) 4*3*9             = ((4*3)*9)                = 108 = l
(12) 2*9*6-8           = (((2*9)*6)-8)            = 100 = d
(13) 8*4+1             = (8*4)+1                  = 33  = !

Seriously 0.1, 1 byte
H

Try it online
Yes, I made my language have a one-byte Hello World program. A less boring answer for 16 bytes:
"Hello, World!".

"Hello, World!" pushes that string onto the stack, and . pops the top value on the stack and prints it.

Arcyóu, 18 15 bytes
"Hello, World!"

Arcyóu is a LISP-like golfing language. Since this is the only thing in the program, we don't need a p function or even parentheses. Just quotes.

No need for the disclaimer here. Newer languages are allowed and even encouraged this time.

Kotlin, 49 bytes
fun main(a:Array<String>){print("Hello, World!")}

This is a programming language created by JetBrains to overcome the limitations of Java (like Scala), be fast (like Java itself) and yet retain full interoperability with Java. This means that Kotlin can easily call Java code ... and vice versa.

AutoHotkey, 61 bytes
DllCall("AllocConsole")
FileAppend % "Hello, World!", CONOUT$

AHK was written to automate Windows tasks and it seems as if the authors considered StdOut/In as an after thought. This is the shortest method I could come up with. When executed the console will flash with Hello World! and exit immediately, it would require additional code (either adding a Hotkey or #persistent or sleep command) to keep the console active, however I feel this does the job and meets the requirements. I could also make the program with DLLCall("AttachConsole, Int, -1") so that it can be executed from the command line and write to the same console it was executed from, however this code golf.

Greetings from the future! I can't tell if this worked at the time but it works now and its 27 bytes: FileAppend,Hello`, World!,*

X.so, 48 42 bytes
$A($Main("X"Include"Hello, World!"X.Show))

Requires XCore to run, so it can use the X.Show command.

Par, 14 bytes
`Hello, World!

I don't know Par, but it looks golfy.

Templates Considered Harmful, 50 bytes
St<72,'e','l','l','o',44,32,87,'o',114,'l','d',33>

Templates Considered Harmful is a language defined by C++ templates. The St template creates a string of characters, which is then implicitly printed to STDOUT.

Factor, 17 21 bytes
Push a string, then print it without quotes.
"Hello, World!" print

20 bytes! Remove the space, better to use write

Also the link is dead, you can use link to https://factorcode.org

18 bytes

@chunes very nice

Jolf, 14 bytes
"Hello, World!

Records a string, implicit output. Try it here.

Jolf, 9 bytes, cheating
(unprintable chars replaced with ?):
e.$nsp#0?
e         evaluate as Jolf code
 .         from the object
  $   #     nsp, get
       0    property 0
        ? (08, backspace character; restrain implicit output)

nsp is an object on the interpreter page that contains example programs. The zeroth one is the Hello, World! program.
Try it here.

This is a catalogue, is it not? Therefore, this answer is completely valid.

@SuperJedi224 Indeed, yes. Fixing.

Samau, 15 bytes
"Hello, World!"

Samau is yet another stack-based golfing language.

Eodermdrome, 18 bytes
al(Hello, World!)a

Replaces the a - l edge on the initial graph with the a node, and outputs Hello, World! in the process.

Hi, your program works, but not for the reason you think - it actually matches the o-g edge, because the l in your program must represent  a node with only one outgoing edge.

ROOP, 17 bytes
"Hello, World!"
h

At the beginning an object is created with the string that is in quotation marks, then the h operator prints all existing objects and ends the program.

BASIC-80, 16 bytes
BASIC-80 aka MBASIC does not need a trailing " to end string constants at the end of the line, so...
1?"Hello, World!

...is all you need.

CP/M nostalgia...
A>mbasic
BASIC-80 Rev. 5.21
[CP/M Version]
Copyright 1977-1981 (C) by Microsoft
Created: 28-Jul-81
32824 Bytes free
Ok
1?"Hello, World!
run
Hello, World!
Ok
system
A>_

Visual Basic.NET, 63 bytes
Module A
Sub Main
System.Console.Write("Hello, World!")
End Sub
End Module

JavaScript function golf, 19 bytes
p("Hello, World!");

I made this[1] for you!
JavaScript function golf is included into the language page HTML, so use it right from the console!
If you want it as an alert, here you are (21 byte):
p2a("Hello, World!");

That said, I finally got time for improvement of the framework.
[1]: I mean, the language golfing framework.

Welcome to PPCG. This is a good start for a Golfing language, however there a lot of features of JavaScript, like Prototypes, that you might want to take advantage of (e.g. 42.s() could turn a number into a string instead of i2s(42).) If you want help or tips, feel free to visit http://chat.stackexchange.com/rooms/27364/esoteric-programming-languages for help, tips and showcasing your language.

@wizzwizz4 thanks, but my real introduction to PPCG was a question. :P Also, I have still to learn about prototypes, and I'm not active enough to chat in the PPCG rooms.

@wizzwizz4 42.s() is a syntax error in some js engines, you'd have to do (42).s() which doesn't actually save anything

@SuperJedi224 That was an example. :-P

@zyabin101 You don't need much reputation to chat.

@SuperJedi224 Or you could type 42..s()

Boo, 22 bytes
Quoting from https://github.com/bamboo/boo/raw/master/docs/BooManifesto.pdf:
The guys who came up with “public static void main” were probably kidding, the problem is that most people didn't get it was a joke. The infamous HelloWorld in all its boo glory:
print("Hello, World!")

“public static void main”, that was a good one!

Brachylog, 3 bytes
@Hw

@H is the string "Hello, World!", and w is the write predicate.

Detour, 19 bytes
`u
@"Hello, World!"

Try it online!
This language was not designed with strings in mind.
"How do you fit a string literal into a 2D language represented on a grid of characters?"
You don't! Just put a `, and then define what the `'s stand for  on the bottom with @ signs (sigh)! This will push all its code points to the ` cell, and the u cell will print it as a string
I'll try to come up with a shorter way to fit in strings later. At least it's not Java.

Jolf, 7 bytes
Try it here!
ξrμ\t\x0FΉ\x1B

ξ read three characters and interprets them as a base 256 number index in a gigantic word list. 'Nuff said.

NTFJ, 118 bytes
NTFJ is an esoteric programming language intended to be a Turing tarpit. It is stack-based, and pushes bits to the stack, which can be later coalesced to an 8-bit number. I believe that this is the optimal, using a loop. (Maybe something can be done by hard-coding @ into the string, which would allow for us to double the l. I haven't checked, but I believe this would come out as more bytes.)
Anyhow, this is the full code:
~~#~~~~#~##~~#~~~##~##~~~###~~#~~##~####~#~#~###~~#~~~~~~~#~##~~~##~####~##~##~~~##~##~~~##~~#~#~#~~#~~~@(*~##~#~~~@^)

Or, more readable:
~~#~~~~#~##~~#~~~##~##~~~###~~#~~##~####~#~#~###~~#~~~~~~~#~##~~~##~####~##~##~~~##~##~~~##~~
#~#~#~~#~~~@(*~##~#~~~@^)

All the ~s push 0 and the #s push 1. The interesting part is the output loop:
@(*~##~#~~~@^)
@              Coalesce to bit (top 8 items); is 0 on an empty stack
 (           ) Skip the inside if the top of the stack is not truthy.
  *            Output as character.
   ~##~#~~~@   Push 104 to the stack
            ^  Jump to index 104, which is right here --.
^._____________________________________________________/

The interpreter is here, but with no permalinks as of yet.
Boring Loop-less version, 130 bytes:
~#~~#~~~@*~##~~#~#@*~##~##~~@*~##~##~~@*~##~####@*~~#~##~~@*~~#~~~~~@*~#~#~###@*~##~####@*~###~~#~@*~##~##~~@*~##~~#~~@*~~#~~~~#@*

Doubling (:) the l character, 122 bytes:
~#~~#~~~@*~##~~#~#@*~##~##~~@:**~##~####@*~~#~##~~@*~~#~~~~~@*~#~#~###@*~##~####@*~###~~#~@*~##~##~~@*~##~~#~~@*~~#~~~~#@*

Oration, 28 bytes
listen
capture Hello, World!

Fun to write.

You can include the 32-byte version: Literally, print("Hello, World!").

Ooh nice, thanks @CᴏɴᴏʀO'Bʀɪᴇɴ .

Can I figuratively print something? :P

@Downgoat yes, but the compiler ignores such frivolity.

Can't you remove \nthat's it?

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ yeah, forgot I fixed/messed that up when I added python 2 support.

@EᴀsᴛᴇʀʟʏIʀᴋ Now you can replace your older version with the newer one.

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ ---yeah, I did.--- er thanks

NTFJ, 106 bytes
~#~~#~~~@*~##~~#~#@*~##~##~~@::**~##~####@:*~~#~##~~@*~~#~~~~~@*~#~#~###@**~###~~#~@**~##~~#~~@*~~#~~~~#@*

Try it online!
NTFJ is an esoteric programming language, made by user @ConorO'Brien, that is intended to be a Turing tarpit. It is stack-based, and pushes bits to the stack, which can be later coalesced to an 8-bit number.
How it works
Output          Stack
H  ~#~~#~~~@*
e  ~##~~#~#@*
   ~##~##~~@    l
ll ::**         l
o  ~##~####@:*  l o
,  ~~#~##~~@*   l o
   ~~#~~~~~@*   l o
W  ~#~#~###@*   l o
o  *            l
r  ~###~~#~@*   l
l  *
d  ~##~~#~~@*
!  ~~#~~~~#@*

Fantastic job!!

::**==:*:*.

@CalculatorFeline Yeah, it can be either way.

Javascript (Nashorn), 22 bytes
Nashorn is the JS engine that comes built in to Java.
print('Hello, World!')

Gogh, 14 bytes
"Hello, World!

This one is pretty self-explanatory. Gogh has self-closing strings, so if there isn't a closing double-quote, it tacks one on the end and you have yourself a string.
You can run it from the command line like this:
$ ./gogh o '"Hello, World!'

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

Try it online here.

The initial block doesn't need begin & end.

Scratch, 2 blocks

Self explanatory really.

You're missing a comma in "Hello, World!" Also, I believe the byte count for Scratch submissions is usually done with this: http://scratchblocks.github.io/

@quartata That means this script takes up 43 bytes.

@aspaghetto  Is this the meta discussion you mean: https://codegolf.meta.stackexchange.com/questions/673/golfing-in-scratch

@haykam  I don't think it should be 43.   https://codegolf.stackexchange.com/a/84031/24812 has the exact same program in scratchblocks2 format and it is 33 bytes.

JavaScript (Node.js), 28 bytes
console.log("Hello, World!")

We already have a JavaScript answer at 22 bytes.

@ZachGates But that answer runs in browser environment. My answer runs in Node.js.

.kill();, 39 bytes
Try it here! Github.
SFTp^B2lA=ZkW`j\9@+*+@9\j`WkZ=Al2B^pTGT

Alright, so I made another monster! This is how this works. First, the code is iterated through, and a resulting string is made. First, let's look at the first character and some related information:
char: S
opposite char: T
average char floored: (@S + @T) / 2 = (83 + 84) / 2 = 83.5 => 83 = S
index: 0
result: S

Each character in the new string is calculated by averaging the values of the current char and the char that lies the same distance from the end of the string; this value is incremented by the index (starting at zero) then floored. The resulting character is appended to the result.
Once this result is made, we look for a valid base64 string in it. This is what that result looks like:
SGVsbG8sIFdvcmxkIQ==?UOs#yq'vZ_,Rc!4xky

This will result in the string SGVsbG8sIFdvcmxkIQ== being found as the base 64 string for "Hello, World!", and is thus outputted.
(When no such string is found, then a more complicated algorithm ensues that transpiles this to JavaScript, so this is most definitely turing-complete and thus a valid language.)

Pickle, 34 bytes
cbuiltins\nprint\n\x8c\rHello, World!\x85R.

Replace the escape sequences by their appropriate character code.
Surprise. Python's default serialization implementation actually uses an interpreter over a stack-based language. Just call pickle.load on it to run it.

UGL, 80 bytes
cuu$u$$$$$$*$d*O$*u$*u$O$@++u$O$O^^+$O@@$$uu**dO%$$*$**$O@$*$u*dddO%$OuuuO%OdOuO

Try it online!
With comments:
#H  e   l   l   o   ,     W  o   r   l   d   !
#72 101 108 108 111 44 32 87 111 114 108 100 33
cuu$u$$$$$$*$d*O  #print H  72        (stack:2 3 3 3 3 3 3)
$*u$*u$O$@        #print e  101       (stack:101 2 3 3 3 3 101)
++u$O$O           #print ll 108 108   (stack:101 2 3 3 108)
^^+$O@@           #print o  111       (stack:108 111 101 2 3 3)
$$uu**dO          #print ,  44        (stack:108 111 101 2 3)
%$$*$**$O@        #print    32        (stack:32 108 111 101 3)
$*$u*dddO         #print W  87        (stack:32 108 111 101)
%$O               #print o  111       (stack:32 108 101 111)
uuuO              #print r  114       (stack:32 108 101)
%O                #print l  108       (stack:32 101)
dO                #print d  100       (stack:32)
uO                #print !  33        (stack:)

Which part is the actual 80-byte source code? The non-space prefixes of the lines? Might be best to include that separately for clarity.

Tellurium, 17 bytes
µHello, World!~^

Well, this is pretty easy to explain.

µ starts reading the string
~ stops reading the string, and stores it in the selected cell.
^ outputs the selected cell's value, which is currently "Hello, world!"

Alternate version (5 bytes)
This one uses the preinitialized variable !o, which expands to "Hello, World!".
µ!o~^

OP says you can use languages made after this challenge.

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Yeah, I know, but using a builtin Hello World seems kind of like cheating.

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!

Unlike our usual rules, feel free to use a language (or language version) even if it's newer than this challenge. 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.

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Oh, I didn't notice that :P

Which of them??

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ First one.

64-bit Windows NT executable, 261591 bytes
Because why not?
Anyway, here's a 89,890-byte ZIP archive containing this executable: http://pastebin.com/raw/pJ6CeNuG (encoded in Base64)
------EDIT------

we don't allow link-only answers for off-site code

Okay. The C code I compiled the executable from is the classic Hello World program:
#include "stdio.h" // Use <cstdio> on C++
int main(){
    printf("Hello, World!");
}

The compiler is GCC without optimizations. Maybe other compilers (such as Intel C(++) Compiler or Clang) can generate smaller executables.

@downvoter Did you get a smaller/larger executable?

@Matheus Avellar got a much shorter executable (1175) from calling WriteConsoleA directly in asm (in a 32-bit PE executable).  Did you even strip the compiler output of debug info?  261k is ridiculously huge, it's like an ungolfed baseline that you might mention in a real answer.

INTERCALL, 311 bytes
INTERCALL IS A ANTIGOLFING LANGUAGE
SO THIS HEADER IS HERE TO PREVENT GOLFING IN INTERCALL
THE PROGRAM STARTS HERE:
PUSH LXXII
PRINT
PUSH CI
PRINT
PUSH CVIII
PRINT
PRINT
PUSH CXI
PRINT
PUSH XLIV
PRINT
PUSH XXXII
PRINT
PUSH LXXXVII
PRINT
CALL ONE VII
PUSH CXIV
PRINT
CALL ONE V
PUSH C
PRINT
PUSH XXXIII
PRINT
END

It can probably be more golfed, but coding in INTERCALL is very hard.
CALL ONE jump to a line, execute it and return to the line after the calling line.

remove the AND's for more golfing

Apps Script + Google Sheets, 39 bytes
Script
function Q(){return"Hello, World!"}

Sheet
=q()

Original, 40 bytes
Script
function Q(){return "Hello, World!"}

Sheet
=q()

Can't you do return"Hello, World!"?

DOG, 20 bytes
bark "Hello, World!"

Casio BASIC, 15 bytes
There is a TI-BASIC answer, but no Casio BASIC ? what a shame !
Fortunately, I went here
"Hello, World!"

Unlike in TI-BASIC, you can't thug around the closing " (you still can with parentheses tho).
However, lowercase letters are 1 byte long (on recent models, it might not have been the case with previous ones, but writing lowercase letters was a PITA anyway).

S.I.L.O.S, 19 bytes
print Hello, World!

Seems legit!

This is a 19 bytes.

@ConorO'Brien whops, I can progam, but I can't count to 19.... :(

Ironic... the nineteenth byte ;)

Cow, 1539 Bytes
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO MoO MoO MoO MoO MoO Moo Moo MoO MoO MoO Moo OOO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo Moo MOo MOo MOo MOo MOo MOo MOo MOo Moo MoO MoO MoO Moo MOo MOo MOo MOo MOo MOo Moo MOo MOo MOo MOo MOo MOo MOo MOo Moo OOO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo

...I count 1539 bytes.

What? O.o I don't.

Well, unless this is in a special encoding, there are 1539 characters thus 1539 bytes.

I've correct it.

This seems to print a non-breaking space (0xa0) instead of a regular space (0x20). https://tio.run/nexus/cow#@u@b768wivHhfIAGqb35WNTkK/j7j4YxYKN4kMSp/xDA@USqIdZvRJo3ePJp/v//AA

D: the W isn't capitalized

261 bytes, which is a trivial variant of the brainfuck solution. I'm sure COW can do better, I just don't know what methods could be used to beat recurrence relations

Jellyfish, 15 bytes
P"Hello, World!

Try it online!
Not terribly interesting, but for completeness' sake...

ARMv7 machine language on Linux, 40 36 32 bytes
 0: fa000002         blx 12          ;put string addr in lr; thumb mode
 4: 48 65 6c 6c 6f   "Hello, World!\0"
    2c 20 57 6f 72
    6c 64 21 00
12: 2001             movs r0, #1     ;stdout is fd=1
14: 220d             movs r2, #13    ;length of string
16: 4671             mov r1, lr      ;put string addr in r1
18: 2704             movs r7, #4     ;select write() syscall
1a: df00             svc 0           ;syscall
1c: 2701             movs r7, #1     ;select exit() syscall
1e: df00             svc 0           ;syscall

To try this out on a Raspberry Pi or Android device with GNURoot, compile and run the following
const char main[]="\2\0\0\xfaHello, World!\0\1 \r\"qF\4'\0\xdf\1'\0\xdf";

Caker, 294 bytes
ωΩθΩθθΩθΩθθθΘΩθθΩθθΩθΩθΩθΘθθΩθΩθθΩθθΘΩθθΩθΩθθΩθθΘΩθθΩθΩθθθθΘθΩθΩθθΩθθΘΩθΩθθθθθΘΩθΩθΩθΩθΩθθθΘθθΩθΩθθθθΘθθθΩθθΩθΩθΘΩθθΩθΩθθΩθθΘΩθθΩθθΩθΩθθΘΩθΩθθθθΩθΘ

Explanation:

ω flip the cell at the left of the tape head if the current cell is 0, at the right otherwise
Ω move the tape head leftward if the current cell is 0, rightward otherwise
θ push the current bit on the print stack
Θ print the character in the print stack and clear the print stack

-1 language name makes me want cake :P

Ru, 15 bytes
“Hello, World!”

Body must be at least 30 characters; you entered 29.

Haxe, 56 bytes
class H{static function main(){trace("Hello, World!");}}

Test it online!

Logicode, 121 bytes
var a=11011
var l=@(a+00)
var o=a+11
out @1001000+@(a+01)+l+l+@o+@101100+@10000+@1010111+@o+@1110010+l+@1100100+@10001

As Logicode works on binary strings, it's pretty hard to convert stuff to ASCII. In comes the @ operator!
It basically converts a binary string to its ASCII counterpart, so something like @1001000 turns into H (1001000 is 72 in binary, and H's ASCII code is 72).

This prints Hmllo,World on TIO.

Kotlin, 22 bytes
print("Hello, World!")

There is an existing answer which includes a main function and a class definition, which aren't actually necessary when running Kotlin as a script (.kts).

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!

WSF, 223 bytes
Stack Exchange cannot display this code properly, so here is a reversible xxd hexdump:
00000000: 2020 2020 2020 2020 2020 2020 2020 2020
00000010: 2020 2020 0a20 200a 2020 2020 2020 2020      .  .
00000020: 2020 2020 2020 200a 2020 2020 2020 2020         .
00000030: 2020 2020 2020 2020 2020 2020 200a 2020               .
00000040: 2020 2020 200a 2020 0920 0920 0920 0920       .  . . . .
00000050: 2009 0a09 200a 2020 2020 0909 200a 2020   ... .    .. .
00000060: 0909 2020 2020 2020 2020 2020 2020 2020  ..
00000070: 0909 0909 2020 2020 2020 0909 200a 2020  ....      .. .
00000080: 2020 0909 0920 0920 2020 2020 2020 2020    ... .
00000090: 2020 2020 2020 2020 2020 2020 2020 2020
000000a0: 2020 2020 2020 0909 200a 0909 2020 2020        .. ...
000000b0: 2020 0909 2009 2009 2009 2009 2009 2009    .. . . . . . .
000000c0: 0909 2009 2009 2009 2009 2009 2009 2009  .. . . . . . . .
000000d0: 2009 0909 200a 2020 0909 200a 0909 0a     ... .  .. ....

Ruby inspected string:
"                    \n  \n               \n                     \n       \n  \t \t \t \t  \t\n\t \n    \t\t \n  \t\t              \t\t\t\t      \t\t \n    \t\t\t \t                               \t\t \n\t\t      \t\t \t \t \t \t \t \t\t\t \t \t \t \t \t \t \t \t\t\t \n  \t\t \n\t\t\n"

There's a 174 byte one on TIO

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.

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

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‹

Nope. It's 17 bytes.

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

Oh. Didn't realise it worked that way, I'll change it.

Also why downvote simply because I didn't understand string encoding? Seems a little mean.

@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?

That was in the above confusion. I'll remove it from the code

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.

Not in UTF-8 but I'm not sure about other encodings. s ∫ main [ is needed to prefix all stack mode languages so...

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.

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.

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)

Dammit hodor, why?

You should answer this with HODOR: http://codegolf.stackexchange.com/questions/48907/hodorize-a-string

Turing, 18 bytes
put"Hello, World!"

Is this the correct github page? https://github.com/Open-Turing-Project/OpenTuring

Welp, I'm blind.

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.

MY, 1 byte.
Here is the hex:
FF

I'm finally ready to reveal my language. It's still a major WIP, and the undefined byte meaning is temporary (except for maybe 0xFF). I will eventually update this to include a non-hacky solution when MY is able to do that.

I did add another solution, this time not relying on a built-in! https://codegolf.stackexchange.com/questions/55422/hello-world/127294#127294

SASS, 32 bytes?
\:after
  content:"Hello, World!"

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.

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

Braingolf, 17 bytes
Got bored, made my own language, here's Hello World
"Hello, World!"&@

Explanation:
"Hello, World!"    Push the 13 chars of Hello World to the stack as charcode integers
               &@  Pop the entire stack and print as chars

Alternatively, here's hello world from before I added multi-char strings and printing:
#!#d#l#r#o#W# #,#o#l#l#e#H@@@@@@@@@@@@@

Explanation:
#!                                 Push the charcode of char '!' to the end of the stack
  ....................             Do this for every character in "Hello, World!" in reverse order
                      @@@@@@@@@@@@@  Pop and print the last element of the stack 13 times

outdated, 2. doesn't even print the right Hello, World!

@ASCII-only fixed

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

Fishing, 25 24 bytes
[+_
|C]`Hello, World!`Ni

It exits with an error.
Fishing, 34 bytes
v+CCCCCCCC^]
  `Hello,
  N`!dlroW

Without errors.

Aheui, 147 144 bytes
발따밤따빠받나파빠밣다빠밦다빠받타밢밢따밦다밤밣따밦밦따빠밣다파받따빠받다파빠빠밠타밣밢따아멓희

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.

Emoji, 23 24 bytes
Hello, World!➡

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

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.

Set, 123 bytes
set ! H
set ! 101
set ! 108
set ! 108
set ! 111
set ! 44
set ! 32
set ! 87
set ! 111
set ! 114
set ! 108
set ! 100
set ! 33

Needed to use raw ASCII codes because lowercase letters are reserved for variable names.
Try it online!

Wow, someone actually used this language. I'm both surprised and very happy

@MatheusAvellar If you haven't yet noticed it has been used in the largest polyglot in existence.

I had no idea! That's the coolest! Hahaha

You can use W instead of 87

@ASCII-only but the bytecount is 123

@MDXF :||||||||

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.

AsciiDots, 18 bytes
.-$"Hello, World!"

Try it online!

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

123

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

You can move the topmost * one line up

Also, what is the 4-byte golf? I'm assuming it's removing one character from the right side of the print loop?

re: topmost *: never mind. it appears you can remove it completely

@ASCII-only yes (about 4-byte golf)

Flipbit, 148 134 129 bytes
^>>>^>>>.^<<^<^<<^>>>>>.^<<<^>>>..^<^>.[<]<?>^>^>>.<<^<^>>>.<<<^>>^>^>^.<<<^<^<^>>>>>.[<]?^>>>^>.<<<<?>^>^>>.<<<^>>>.<<<<<?>>>>^.

Try it online!
-14 bytes thanks to Aaron Miller
-5 bytes thanks to Bubbler
How it works
Flipbit uses an infinite tape, consisting of either a 1 or a 0 per cell. The way it outputs is getting all previous elements in the tape, converting that from binary, then indexing into Unicode.

134 bytes

129 using Thanos-oriented programming.

CRPL and its sister language PRPL, 21 bytes
Bit of an obscure language, but the official tutorial doesn't contain a Hello World program so this at least is worth something.
"Hello, World!" Trace

"Hello, World!" pushes the string Hello, World! to the stack, and Trace pops an item from the stack and add it to the trace log, the closest thing the language has to SDTOUT or a console.
Alas, for this language is too obscure for Dennis's gadget; however, I have written the following interpreter in JS with all the complexity needed for this demo. I may one day make it support more.

var code = '"Hello, world!" Trace';
var stack = [];
var vars = Object.create(null);

var literals = [];
code = code.replace(/"(.*?)"/g, (m, $1) => 'lit' + [literals.length, literals.push($1)][0]).split(/\s/);

for (var token of code) {
    if (token.match(/^lit(\d+)$/)) {
        stack.push(literals[token.slice(3)]);
    } else if (token.match(/^-?\d+.?\d*/)) {
        stack.push(+token);
    } else if (token.startsWith('<-')) {
        stack.push(vars[token.slice(2)]);
    } else if (token.startsWith('->')) {
        vars['v' + token.slice(2)] = stack.pop();
    } else {
        switch(token) {
            case 'Trace5':
                console.log(stack.pop());
            case 'Trace4':
                console.log(stack.pop());
            case 'Trace3':
                console.log(stack.pop());
            case 'Trace2':
                console.log(stack.pop());
            case 'Trace':
                console.log(stack.pop());
                break;
            default:
                throw new Error(token + 'is not implemented.');
        }
    }
}

No language is too obscure, you just have to ask for it on https://talk.tryitonline.net lol

Yeah probably. You could've just edited it yourself.

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!

rk, 22 + 2 (-e) = 24 bytes
print: "Hello, World!"

Requires the -e flag (remove necessity for rk:start). Try it online!

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.

Min, 20 bytes
"Hello, World!" puts

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!

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.

Meq, 145 111 bytes
.==++>:+>+>[:++++++++>]:=+>====++++>===++>.===+++++++>:=+>:=++++>:++++++++>:>===+++rp>p>>p>p>p>p>p>p>p>p>p>p>p!

Thanks Steadybox for saving 34 bytes

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

@MartinEnder It does not, it prints Helo World. (And the original prints Hello World.)

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

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

as big as = is

somebody1234 is me, but I'm pretty sure I basically stole it from somewhere else lol

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.

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

Try it online!

This looks like an interesting language. The author appears to be aware of TIO!

2DFuck, 157 150 bytes
.!.!..!.!....!..!..!.!.!.x[!.!..!.!..!..rv].!..!.!....!..!.!.!..!....!.!......!.!.!.!.!...!.!..!.!....!.!...!..!.!..!..!.!..!...!..!..!.!....!.!....!.

Try it online!
Print He, print l twice, print o, World!

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!

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

I don't understand why anybody cares about this language .__.

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

Link to interpreter no longer works

@ascii-only fixed

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

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.

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.

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?

1+, 87 83 bytes
11+""+"""+"/*^/"\+""+";\\+"*"1+;/+""";;(|1+1+1+)";/^""1()"+()+"1+";+^;;\";();/;;1+;

Try it online!
This should be very golfable, but it is hard to golf 1+ directly.

Nice! I'm doing nothing now.

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.

Ral, 103 bytes
What better way to introduce a new language than by posting the 768th "Hello, World!"?
Hand-made code, can probably be improved a lot.
11+:+:+:0=1+:+:+::+:.+0*/-::1+.0*+:::..1+1+1+::.0*:+:+:11+1+:+:++..10*1+1+1+:+:+:+-..1+1+1+...0*:+:+1+.

Try it online!

Cool language! I like the mix of stack and random access.

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.

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.

Roj, 18 bytes
I love this simple BASIC dialect ...
out"Hello, World!"

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

C64 BASIC, 16 characters, 20 bytes
If HELLO, WORLD! is fine.
0?"HELLO, WORLD"

You don't mean the closing quotation mark when you PRINT In Commodore C64 BASIC, so you may save one character and one tokenised bytes by removing it.

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!

Vyxal, 10 bitsv1, 1.25 bytes
kH

Try it Online!
Pushes the string "Hello, World!"
Alternatively,
Vyxal, 50 bitsv1, 6.25 bytes
`ƈṡ, ƛ€!

Try it Online!

It reads: 1/2 V, 1/2 v!

10 bits = 1.25 bytes with Vyncode

MathGolf, 14 bytes
'H╕○ô╣·'W╕7ÿ'!

Try it online.
Or alternatively just the plain and simply:
"Hello, World!

Try it online.
Explanation:
'H              '# Push "H"
  ╕○ô            # Push compressed "ello"
     ╣·          # Push compressed ", "
       'W       '# Push "W"
         ╕7ÿ     # Push compressed "orld"
            '!  '# Push "!"
                 # (implicitly output the entire stack joined together to STDOUT)

"Hello, World!  "# Push "Hello, World!"
                 # (implicitly output the entire stack joined together to STDOUT)

Rutger, 23 bytes
Print["Hello, World!"];

Try it online!
An old language of mine, and fairly basic, but included for comprehension.

Wiki writing time?

@Razetime If I can find time among all the other language wikis I should be writing :P

I'll figure it out once I'm done with the Add++ wiki, maybe.

Befalse, 43 30 bytes
"!dlroW ,o"\
/?$\!"Hell"/
\. /

If this gets down to 1 line, it would be much shorter without all the spaces on the second line. I’ll golf this further.
Thanks to Jo King♦ for golfing this further. I think it can be golfed even more now.

I don't know much about Befalse, but you can do fold it back along the second line for 30 bytes or use the call and return commands for 31 bytes

Shu, 931 bytes
IncreaseBy100 DecreaseBy10 DecreaseBy10 DecreaseBy10 IncreaseBy1 IncreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 DecreaseBy1 DecreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 DecreaseBy1 DecreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 IncreaseBy1 PrintChar Clear IncreaseBy10 IncreaseBy10 IncreaseBy10 IncreaseBy10 IncreaseBy1 IncreaseBy1 IncreaseBy1 IncreaseBy1 PrintChar Clear IncreaseBy10 IncreaseBy10 IncreaseBy10 IncreaseBy1 IncreaseBy1 PrintChar Clear IncreaseBy100 DecreaseBy10 DecreaseBy1 DecreaseBy1 DecreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 IncreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 IncreaseBy1 IncreaseBy1 IncreaseBy1 IncreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 DecreaseBy1 DecreaseBy1 PrintChar Clear IncreaseBy100 PrintChar Clear IncreaseBy10 IncreaseBy10 IncreaseBy10 IncreaseBy1 IncreaseBy1 IncreaseBy1 PrintChar Clear

Welcome to the site! Seems like an interesting language, I'll be interested to see more examples when you finish them.

Source Engine Console, 18 bytes
echo Hello, World!

You can't try it online unless Valve ports Half-Life 2 to WASM or something.
This script is pretty basic. It's perfectly valid to echo like this without quotes in the Source Engine.
The Source Engine is a game engine developed by Valve Software, and used in all their games after 2004 (until DOTA 2 in 2015). It provides basic scripting through console commands. You can test this by opening the developer console (enable in settings and press the ` key) and pasting the line.
Tested in Team Fortress 2, CS:GO and Source SDK Base 2013 (Multiplayer).
By inspecting some leftover E3 demo scripts in Half-Life 2, it's revealed there was a rem command which could be a shorter 17 bytes, but this is no longer present in the engine (and I assume that a rem doesn't count because it doesn't print anything). I've yet to test if it exists in Source 2004, but can confirm it's missing in Source 2013.
Technically, the console isn't STDOUT, however the only way to really output to STDOUT is by using the SDK to make a game of my own (obviously compiling to a very large size).

!@#$%^&*()_+, 17 bytes
 ^dlroW ,olleH(@)

Try it online!

BRASCA, 14 bytes
Another simple Hello, World program.
`Hello, World!

Explanation
`                  - Push everything from here to the next backtick (or EOF) to the stack
 Hello, World!     - The text, duh :^)
<implicit output>  - Output the contents of the stack reversed

Language Link
Github Repo

Pxem, 15 bytes (filename) + 0 byte (contents) = 15 bytes
Filename
Hello, World!.p
Content
(none)
Description of program
The program above should output the phrase without LF.
If you'd like LF, here is an alternative filename (19 bytes);
ak.-Hello, World!.p
Description of language
The main feature of this programming language to recognize filename as main routine of the program; content of the file is subroutine.
Implementations
So far there are two major implementations:

Designer's original C++ implementation --- Distributed as pxemi.7z.
wktk's Ruby implementation

Welcome to the site! Nice first answer, this looks like an interesting language.

Python3, 9 Bytes
import qz

Try online
It's kind of cheating because it's using an external package but I don't think there is another way to pass the boring:
print("Hello, World!")

The first one may be valid, but the second one has almost certainly been done already. Also, it's recommended to link to an online interpreter. I'd suggest TIO, it can even generate markdown for you. Here's an example link

@user Duplicate answers are allowed. But even were they not, there's clearly been some effort here to post an alternative to the most obvious approach.

@user Link doesn't work since the module qz isn't installed there, and can't be because of TIO's heavy restrictions :)

Duocentehexaquinquagesimal, 28 bytes
1Ƶ¸ñ=öu¯2–sε`;ÈùˆζT¿āΔIÈ3Wÿ»

Try it online!

+1 just for the name.

@Ausername Lol, yeah I picked it because (at least I thought) it was encoded in Base 256. Turns out, since 05AB1E needs to reserve the bullet point for starting and ending Base-256 numbers, it actually uses base 255, but I didn't feel like updating all my answers :P

Pinecone, 22 bytes
print: "Hello, World!"

Vyxal, 2 bytes
kH

Pushes the built-in string Hello, World!, with implicit output.
Try it Online!

1L_a, 3549 2532 bytes
 **********************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
 **   *   **    * **       *   *  *  *   **      * *   *    **  * *     *      **  *** *    *  *  *    **      **  *** **    *  *  * ***    **   *       *  **     *  ** *       **  *** *    *  *  *     **       *** *   *   *  *  * *    *  * *   *   *    *   **      *    ** ***   *       *  **  * *     *  **     *  ** *       * *    **  **   * *    *  **  * *  *      *  **  * *   *   *   **  **   *  * *      *  *  *    *
 *       * *  * *     * *    * *  **     **  *   *          *  *      * *  **       *  *  * *  **   **     **       *  *     ** **   *   *  *        *      *   **    *     ***       *  *  * *  **   * *    ***   **  *     * *  **   *       *         *      *     ***   **     *        *      *  *      * *      **    *     **   *   **     *      *       *   *** **    * *      *         *       *       *     ** *  **   **
    ***    *       *    **  *     *    *     **      *        *    **      *    *     **       *    *   *  *    *     **        *    ** **      ***  ** **    * *        *   *    *     **       *    *    *   **      **         *    **   *     * **   **   *    ** *     *   *      ***  ** **    *    **       ** *        *   **      *   *      *  **   *    *      **         *     * **   **   *      **  ** * **     *    *  *
***   **     *  *  *   **   *  *    *     *  *    *     **  *   **  *  **  ** *******    *  *    *  *****  ** * *****    **  *    *     ******  ***  *   *****  *     *  *   ** * *****    *  *    *  **  **   *    *       *  *    *      *****    ***      **    *  *  *  *********  ***  *   ****   **  *  ***  *  *     *  *   *    *  *********  *      *****     *      *  *** ****    ***       *****  **     *  *  *    *  ***
 **********************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************

Try it online!
(heh, line wrapping makes it look wierd)
Automatically generated by this program, with some golfing (manual + golf.rb).
It is very hard to program in 1L_a, so I use generator. Generator creates cells, each cell prints one bit. It iterates through all possible cells with height 6
and no more than 5 inner asterisks to find a cell that prints the needed bit. Generator fails if height is less than 6 or max asterisk count is less than 5.
This is an ungolfed version with cells visible (13*8 = 104 cells):
  ****** ****** ****** ***** ****** ****** **** **** ****** ***** **** ****** ***** ***** ****** **** ****** ******* ***** ****** ***** **** ****** **** ****** ***** **** ****** ***** **** ******* **** ****** ***** **** ****** ***** ***** **** ***** ******* ***** ***** ****** ***** **** ****** **** ****** ****** ***** ****** **** ******* **** **** ****** ****** **** ******* ***** ****** ****** **** ******* ***** **** ****** ***** ***** **** **** ****** ******* ***** **** ******* ***** ***** ****** ***** ***** ***** ****** **** ****** **** ******* ***** ****** **** ***** **** ******* ***** ****** **** ****** **** ******* **** **** ****** *****
  **   * *   ** *    * * * * *         *      * *  * *  *      ** *        ** * *      ** *    * ** * * * ** *     * *         ** *  ** ** * *    * *  * *  *      ** *        ** *  ** ** * **    * *  * *  * * ***      * **   * *         * *  * **       *  * ** ** *         ** *  ** ** * *    * *  * *  *       ** *         ** ** * *   *      * *  * *  * * *    * *  * * *   * *   * *    * *   ** *        *      ** * ** **   * *         * *  * ** * * * ** *     * *  ** *       *  * ** ** *         ** * *      ** *  ** **   * ** * *    * *  * **  * * *  ** *         * *  ** *  * * *   * *   * *   ** *  * **   * *  * * *        * *  * *  *      **
  *         * * *  * * *        * * *    * ** * *  * **   * *  ** *  * *   ** *   * *          * *  * **         * * *   * **         * *  * *  * * *  * **   * **       * **         * *  * *     * ** * **   * *   * *  * *          * *        * *   * **    * *        ** **         * *  * *  * * *  * **   * * *      *** *   ** *  * *     * ** * *  * **   * *         * *           * *        *       * ***   * **       * *          * *        * *  * **         * * *        * **    * *        ** *   ** *   * **       ** *         * *         * *   *** * * * *    * ** * *        * *           * *         * *         * *     * ** * *  * **   * **
     *** *    * *         ** *    * **  ** *       * *    * **       * **         * **  * *        ** *    * ***        ** *    * *       ** *         * *    * *   * *  * *    * *       ** *          * *    * ** ** *        ** **  * ** ** *      * * *          ** *   * *    * *       ** *         * *    * *    * *   * **        * **    * *       * *    * **   * *       * ** *   * **   * *    * ** * *     * *   * *        ** **  * ** ** *      ** *    * ***         * ** * *          ** *   * **         * *   * *         ** *  * **   * *      *        ** **   * *        * *       * ** *   * **   * *        ** *  * ** * ** *       * *    * *   *
* **   * **       *  * *  ** *   ** *   ** *  * *      *  * *   * *  * *    * **  * *   * ***  * *      ** * * *  ** *  ** ** *** ***** *      *  * *      *  * ***** *  * ** * * ***** *      **  * *      *       ** **** **  ** **  * *   * **** **  * *     * *  ** *   * ** * * ***** *      *  * *      *  * **  ** *   * *    * *         ** *  * *      *        ** **** *    ** **        ** *    * *  * *  *  * ***** **** **  ** **  * *   * **** *      ** * * *  ** **  * *  * *     * *  ** *   * *    * **  * ***** *** * **  ** *        ** **** *     * *         ** *  * *** * **** *    ** **         * **** **  ** *       *  * *  * *      *  * *****
  ****** ****** ****** ***** ****** ****** **** **** ****** ***** **** ****** ***** ***** ****** **** ****** ******* ***** ****** ***** **** ****** **** ****** ***** **** ****** ***** **** ******* **** ****** ***** **** ****** ***** ***** **** ***** ******* ***** ***** ****** ***** **** ****** **** ****** ****** ***** ****** **** ******* **** **** ****** ****** **** ******* ***** ****** ****** **** ******* ***** **** ****** ***** ***** **** **** ****** ******* ***** **** ******* ***** ***** ****** ***** ***** ***** ****** **** ****** **** ******* ***** ****** **** ***** **** ******* ***** ****** **** ****** **** ******* **** **** ****** *****

See also 1L_a answer to "Add a language to a polyglot" challenge.

Flurry -bnn, 710 bytes
(){}[(){}[(){}[(){}[(){}[(){}[(){}[(){}(<[{<({}){}>}{<({})({}){}>}][{<({})({}){}>}{<({}){}>}]>)((((<><<>()>[{<({}){}>}<{<({}){}>}{<({})({})({})({}){}>}>])[<><<>()>]{<({})({})({})({})({})({}){}>}))[<><<>()>]{<({})({}){}>})](<{<({})({})({}){}>}[<><<>()><{<({}){}>}{<({})({})({})({}){}>}>]>)]({<({})({})({})({}){}>}{<({}){}>})](<{<({})({}){}>}[<><<>()><{<({})({})({}){}>}{<({})({})({})({})({})({}){}>}>]>)](([{<({}){}>}<{<({}){}>}{<({})({})({})({}){}>}>][<><<>()>][<><<>()>[<{<({}){}>}{<({})({})({})({}){}>}>]])[<><<>()>]{<({})({}){}>})]([{<({}){}>}<{<({}){}>}{<({})({})({})({}){}>}>][<><<>()>][{<({})({}){}>}{<({}){}>}])]({<({}){}>}<{<({}){}>}{<({})({})({})({}){}>}>)](<><<>()>[{<({})({})({})({}){}>}{<({}){}>}])

Try it on the online Flurry interpreter!

Subleq (8-bit), 25 bytes
12 -1 13
1 0 6
3 2 -1
11 11 0
72 101 108 108 111 44 32
87 111 114 108 100 33

Subleq Emulator
This is shorter than the other "Hello, World" samples I have seen online.
Explanation
 0: 12 -1 13                  'Output 12:; 2: is used as a countdown
 3: 1 0 6                     '0: = 0: + 1; move to the next character
 6: 3 2 -1                    '2: = 2: - 1, if 2: <= 0 then exit
 9: 11 11 0                   '11: = 0, goto 0
12: 72 101 108 108 111 44 32  '12: "Hello, "
19: 87 111 114 108 100 33     '19: "World!"

AEWNN, 75 bytes
[8+]cpar2[5+]cpa[7+]cpacpa+++cpa [8+]cpar2[15+]cpa+++cpar2[12+]cpar2++++cpa

Welcome to Code Golf, and nice first answer!

All of these answers are pretty boring (one is a built-in and the string compression algorithm isn't even my own); consider upvoting some cool answers in tarpits / esolangs rather than this one. I'm just putting it here to have yuno officially be a language on CGCC, and because Hello, World! is a good entry point for any language.

yuno, 1 byte
ᴋ

Try it online!
By default, if the k-literal digraph finds no character after it, it just uses H, because I haven't thought of a good behavior for it otherwise so I may as well save bytes on Hello World.
yuno, 2 bytes
ᴋH

Try it online! Uses the built-in string nilad digraph (inspired by Vyxal).
yuno, 8 bytes
“3ԸaϨ;ψ»

Try it online! Uses a compressed string with the exact same compression algorithm that Jelly uses.
yuno, 15 bytes
“Hello, World!”

Try it online! A default string. As caird coinheringaahing points out, the trailing ” can be removed if it occurs at the end of the program.

You can omit the trailing ” from the last one

@cairdcoinheringaahing I could; just felt like leaving it as the default no-optimization method. I'll leave a note though.

Re: 'publicizing it maybe it'll force me to actually write it' (from 'yuno-abandoned' answer): do you have any plans to write-up any kind of list of commands or minimal 'how-to'?

Regenerate, 14 bytes
Hello, World\!

Try it here!
Regenerate is my new regex-match-generation language. The hello world program is pretty simple: just the literal string as a regex, with the ! escaped because it's a metacharacter.

51AC8, 2 bytes
Kh

Try it Online!
Finally an online interpreter. A little quirk you have to press Run twice.

Arduino, 75 bytes
void setup(){Serial.begin(300);Serial.print("Hello, World!");}void loop(){}

Although Arduino does have println(), the challenge said the newline is optional, and print() is shorter.

74 bytes (untested)

If that works, I could make a lot of mine shorter, but I can't test it either -- I can't find my Arduino board.

@tailsparkrabbitear Just tested it. The compiler says error: 'Serial' does not name a type.

Then 82 bytes if I use macro instead.

Yes but that's longer than what I currently have (75 < 82).

Minim, 44 43 42 Bytes
New solution uses the Carriage Return escape character '\r', saving 1 more byte:
[]="\r!dlroW ,olleH".$<[[0]--]._^![0].C=0.

Thanks to @stasoid for the incidental? realization!
With whitespace and comments:
[] = "\r!dlroW ,olleH". ; Insert the value 13, and "Hello, World!" backwards, \
                          into memory starting from index 0
$< [[0]--].             ; Prints the value at the index stored at index 0 as unicode, \
                          and decrements index 0
_^ ![0].                ; Skip the next statement if index 0 is 0
C = 0.                  ; Sets the program counter to 0, which advances to 1 afterwards

Previous solutions prepended the string with 13...
[]=13&"!dlroW ,olleH".$<[[0]--]._^![0].C=0.

... or used ASCII escape character 0xD (CR) in the string:
[]="\x0D!dlroW ,olleH".$<[[0]--]._^![0].C=0.

GitHub Repository

newline is optional

@stasoid You are correct! That is actually a typo held over from the original solution, where I put the string counter IN the string, but it ended up being shorter to prepend the counter with the '&' operator. Thanks for the catch! That actually means I can make this one byte shorter still!

Vim, 14 bytes
iHello, World!

Try it online!

I think this is the shortest it can get

Logomocja, 20 bytes
pisz [Hello, World!]

Logomocja is the Polish dialect of Logo, pic related shows the effect of executing the command in its environment

ErrLess, 17 bytes
SHello, World!S?.

Prints Hello, World! to stdout, without a trailing newline.
ErrLess is a stack-based language I made for fun over the last few months. You can read the docs here, and I also started a tutorial.
Try it online!

Hello Hell, 0 bytes

Since the tape is initialized to "Hello, World!", and the contents of the tape are printed automatically at the end of execution, the blank program is a Hello World program.

FROM HERE TO THERE, 27 bytes
FROM "Hello, World!" TO OUT

Try it online!

JavaScript, 101 85 80 bytes
Thanks to @Redwolf Programs for removing 21 bytes
console.log(String.fromCharCode(72,101,108,108,111,44,32,87,111,114,108,100,33))

Try It Online!

But there is shortest JavaScrpit answer. we allow duplicates.

You can do String.fromCharCode(...array) to join all the characters into a string, saving a lot of bytes

Oh, since you're not doing any preprocessing on the array now, you don't even need .... You can just list the characters, so String.fromCharCode(72,101,108,...)

Woodchuck, 1161 bytes
Woodchuck is a derivative of BF which uses binary trees. Here is the hello world program.
>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[^^<>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[^^<>>[>]>^<^[^]^>>[>]>^<^[^]^<>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^<>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^<>>[>]>^<^[^]^^^^^>>[>]%<%^[^]^>>]^^<>>[>]>^<^[^]^<>>[>]>^<^[^]^<>>[>]%<%^[^]^<<>>[>]>^<^[^]^>>[^^^>>]^^^>>[>]%<%^[^]^>>]^^<<>>[>>>[>]>^<^[^]^].^[^]^<>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>>>[>]>^<^[^]^].^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>>>[>]>^<^[^]^].^[^]^>>[>>>[>]>^<^[^]^].^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>>>[>]>^<^[^]^].^[^]^<<>>[>>>[>]>^<^[^]^].^[^]^^>>[>]%<%^[^]^>>[>>>[>]>^<^[^]^].^[^]^^>>[>>>[>]>^<^[^]^].^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>>>[>]>^<^[^]^].^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>>>[>]>^<^[^]^].^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>]%<%^[^]^>>[>>>[>]>^<^[^]^].^[^]^<<>>[>]>^<^[^]^>>[>>>[>]>^<^[^]^].^[^]^<>>[>]>^<^[^]^>>[>]>^<^[^]^>>[>>>[>]>^<^[^]^].^[^]^

Umm... That's quite complex. However, woodchuck is Turing complete, so...

Python is Magic, 2163 bytes
__builtins__.__getattribute__(__doc__.__repr__.__name__.__getitem__(__doc__.__class__.__class__.__name__.__len__()).__add__(__doc__.__str__.__name__.__getitem__(__doc__.__class__.__class__.__name__.__len__()).__add__(__name__.__len__().__class__.__name__)))(__builtins__.__getattribute__(__annotations__.__class__.__name__.__getitem__(__annotations__.__str__().__len__()).__add__(__doc__.__hash__.__name__.__getitem__(__annotations__.__str__().__len__()).__add__(__name__.__class__.__name__.__getitem__(__annotations__.__str__().__len__()))))(__name__.__len__().__mul__(__name__.__len__().__invert__().__neg__())).__add__(__doc__.__repr__.__name__.__getitem__(__name__.__class__.__name__.__len__()).__add__(__name__.__mul__.__name__.__getitem__(__doc__.__class__.__class__.__name__.__len__()).__mul__(__annotations__.__str__().__len__()).__add__(__doc__.__bool__.__name__.__getitem__(__name__.__class__.__name__.__len__()).__add__(__builtins__.__getattribute__(__doc__.__dir__().__class__.__name__)(__name__).__str__().__getitem__(__doc__.__class__.__class__.__name__.__len__()).__add__(__name__.__eq__.__doc__.__getitem__(__name__.__eq__.__name__.__len__()).__add__(__builtins__.__dir__().__getitem__(__name__.__class__.__name__.__len__().__mul__(__doc__.__class__.__class__.__name__.__len__().__mul__(__name__.__sizeof__.__name__.__len__()))).__getitem__(__doc__.__class__.__class__.__name__.__len__()).__add__(__doc__.__bool__.__name__.__getitem__(__name__.__class__.__name__.__len__()).__add__(__doc__.__str__.__name__.__getitem__(__doc__.__class__.__class__.__name__.__len__()).__add__(__name__.__mul__.__name__.__getitem__(__doc__.__class__.__class__.__name__.__len__()).__add__(__name__.__mod__.__name__.__getitem__(__doc__.__class__.__class__.__name__.__len__()).__add__(__builtins__.__getattribute__(__annotations__.__class__.__name__.__getitem__(__annotations__.__str__().__len__()).__add__(__doc__.__hash__.__name__.__getitem__(__annotations__.__str__().__len__()).__add__(__name__.__class__.__name__.__getitem__(__annotations__.__str__().__len__()))))(__name__.__class__.__name__.__len__().__mul__(__name__.__getitem__.__name__.__len__()))))))))))))))

Try it online!
To check if the code is valid then
import re, sys
allowed = r"A-Za-z().,_"
regex = r"(?:__)?([{}]+)(?:__)?".format(allowed)
banned = r"[^{}]".format(allowed)
script = input()

if re.findall(banned, script):
    raise SyntaxError("Only letters, parenthesis, dot and underscore are allowed.")
print("Valid!")

1311 bytes

@grandBagel Why?

It seems like you've copied this directly from the esolangs page without any modifications (such as the trivial one that @grandBagel points out). This isn't disallowed per se, but you should try to optimise for bytes in [tag:code-golf]

@BgilMidol Here it is with a working interpreter

Lexurgy, 23 bytes
For a tool meant for handling strings, it's surprisingly lengthy to output any string longer than 1 or 2 characters without any input.
a:
*=>Hello\,\ World\!

Seriously, 1 byte
H

Try it online!

Time for the "Seriously?" joke.

Python, 22 Bytes
In Python, this is pretty straight-forward:
print("Hello, World!")

This is equivalent to
import sys
sys.stdout.write("Hello, World!")

which is 44 bytes.
If you are in the interpreter, "Hello World" would return itself, but I doubt it goes to sys.stdout.

Welcome to Code Golf! This site is for competitive programming, so answers should include a byte count rather than just solving the problem.

See Blue's solution, same code, so same byte count. Anyway, if you include a link to TIO like this: Try it online!, there it tells you the byte count: “22 chars, 22 bytes (UTF-8)”.

I don't think this answer deserves three downvotes. It's a duplicate, but those are explicitly allowed under site rules. It didn't have a byte count at first, but this is a new user and it's not uncommon for people to not be sure how the byte counts work at first. It made effort to explain how the answer works, which is already more effort shown than a good 80% of the answers on this challenge.

Lean, 22 bytes
#print "Hello, World!"

Try it online!
Shouldn't be on this list at the moment!

Why shouldn't it be on the list at the moment?

Well, it wasn't until now, was it?

QWERTY, 1 byte
q

QWERTY is a work-in-progress language by me, written in C++. The letters in the word QWERTY will be used in the most trivial programs, however, it will be Turing-complete and hopefully not a tarpit.
Eh, but that's cheap.
QWERTY(non-cheap, charmode), 37 bytes
'Ho'eo'loo'oo',o' o'Wo'oo'ro'lo'do'!o

Yep, it's that bad.
QWERTY(stringmode), 28 bytes
"!dlroW ,oleH"(ddodddddddddd

About 2/3 as good :(
QWERTY(optimized stringmode), 16 bytes
"!dlroW ,olleH"s

Now it looks like every other golfing language.
If you wish to see this example, for some reason, take this link: QWERTY

Etch, 20 bytes
New language! :D
:out"Hello, World!";

99, 283 bytes
Yes there is a language called 99
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

Try it online!

Bit, 637 bytes
BIT 0
BIT 0
BIT 0
BIT 1
BIT 0
BIT 0
BIT 1
BIT 0
BIT 1
BIT 0
BIT 1
BIT 0
BIT 0
BIT 1
BIT 1
BIT 0
BIT 0
BIT 0
BIT 1
BIT 1
BIT 0
BIT 1
BIT 1
BIT 0
BIT 0
BIT 0
BIT 1
BIT 1
BIT 0
BIT 1
BIT 1
BIT 0
BIT 1
BIT 1
BIT 1
BIT 1
BIT 0
BIT 1
BIT 1
BIT 0
BIT 0
BIT 0
BIT 1
BIT 1
BIT 0
BIT 1
BIT 0
BIT 0
BIT 0
BIT 0
BIT 0
BIT 0
BIT 0
BIT 1
BIT 0
BIT 0
BIT 1
BIT 1
BIT 1
BIT 0
BIT 1
BIT 0
BIT 1
BIT 0
BIT 1
BIT 1
BIT 1
BIT 1
BIT 0
BIT 1
BIT 1
BIT 0
BIT 0
BIT 1
BIT 0
BIT 0
BIT 1
BIT 1
BIT 1
BIT 0
BIT 0
BIT 0
BIT 1
BIT 1
BIT 0
BIT 1
BIT 1
BIT 0
BIT 0
BIT 0
BIT 1
BIT 0
BIT 0
BIT 1
BIT 1
BIT 0
BIT 1
BIT 0
BIT 0
BIT 0
BIT 0
BIT 1
BIT 0
BIT 0
BYTES 8
PRINT

You heard me right, 637 bytes
-8 thx to mathcat
Try it online!

You don't need println

Fennel, 22 bytes
(print"Hello, World!")

¯1 byte thanks to @ovs

I think you can omit the space. At least that works with the REPL on the website

@ovs yep that works

EEL - 86 Bytes
=72 !>=101 !>=108 !>=108 !>=111 !>=44 !>=32 !>=87 !>=111 !>=114 !>=108 !>=100 !>=33 !.

Explanation
EEL (Easy Esoteric Lang) is an esoteric programming language created by me, easy to manage, hence the name. Below is a brief description of the language.
.-EEL is based on a vector of bytes initialized to zero, on which basic arithmetic operations can be performed, whose length is equal to 64Kb.
.-EEL allows the reading and writing of one byte at a time in the form of an ASCII character in the standard input and output respectively.
.-EEL has a brief help section which can be viewed from the interpreter.
.-EEL is extremely sensitive, so a wrong input byte can cause a wrong output.
.-EEL does not have an error/exception handling system, so it may crash unexpectedly if a fatal error such as division by zero occurs.
Defined operations:
=000 -> Copy the value of number 000 to the current byte.
+000 -> Add to the current byte, the value of number 000.
-000 -> Subtract to the current byte, the value of number 000.
*000 -> Multiply to the current byte, the value of number 000.
/000 -> Divide to the current byte, the value of number 000 (cannot be zero).
%000 -> Calculate the modulo of the current byte and the value of number 000 (cannot be zero).
> -> Go to the next byte of the vector.
< -> Go to the previous byte of the vector.
? -> Read a ASCII character from STDIN and assign it to current byte.
! -> Write to current byte in STDOUT as an ASCII character.
: -> Open/close the space for comments.
. -> Exit the program.
$ -> Reference to current byte.
NOTES:
The 000 number can be s current byte reference operator ($).
The 000 number (x) must be an integer number, such 0 < x <= 255.
There must be a space character u+0020 after each number 000.
Try the EEL interpreter!

Makina, 19 bytes
New language! :D
P
>t:Hello, World!;

MSWLogo, 16 bytes
pr[Hello, World!

A very long language name that is very weird and yeah, this is your but its this, 80 bytes.
A very long language name that is very weird and yeah, this is your but its this

A Language Programmed While Listening to Godspeed You! Black Emperor, 93 bytes
charms 72. 101. 108. 108. 111. 44. 32. 119. 111. 114. 108. 100. 33. 10﹔
print﹔
give up﹔

This is an esolang, and the goal of the language was to make it as annoying as possible to program.

Perhaps --verbose, 14 bytes
"Hello, World!

Perhaps this will be the first of many Perhaps answers. :p

ｍａｙｂｅ

Cognate, 20 bytes
Print"Hello, World!"
Attempt This Online!

Stack Cats, 94 + 3 = 97 bytes
(^_^_[>_[_*:>^]<^[>+:^[_!:+_+:>-!^_!]<:_^_I_+>_]<:_I_+:>_I^+>_I_+*-!*>+![+]+_!_-^+_)*_:_-^_!_:

Needs to be run with the -m switch, so +3
Try it online!
I'm sure there're still a lot of bytes which can be golfed, but this is the best I could think of so far.
Due to the reversibility of Stack Cats, I found it easier to think about the code in reverse - instead of thinking about how to turn the empty string into "Hello, World!", we want to think about how to consume the string "Hello, World!" from the stack.
I won't explain in detail what the code does, but it doesn't use any complicated tricks, and you can get a good idea by running it with the -D flag on the string "Hello, World!", or by pasting the code in the parenthesis in this site I made to help me create it, and typing slowrun() in the console. I found the code to create 100 33 8 by going over all programs under length 12, running them on 0 0 -1, and calculating the result's distance to 100 33 8 with BFS, and also used BFS to find what numbers can be converted to others with short code (for example converting 72 to 8 with 101, or converting 87 to -8 using 111).

You don't have to count flags anymore, so just 94

Knight, 16 bytes
O"Hello, World!"

Gaia, 14 bytes
“Hello, World!

Try it online!
Strange that there wasn't a Gaia answer to this challenge yet, given that there's so many answers.

Functional(), 139 129 bytes
0,1,=,:(W,& a(>(a(:(Z,&()(W()0)))),W))0 Z Z()1()1 W()W()>()W()>()> >()>()W()1()0()0()Z W 1()1()1()> >()> Z W 1()W()>()Z W()1()0 Z

Try it online!
Try the 139B version online!

Rol, 24 bytes
println("Hello, World!")

Rol is a new language I'm creating for the purposes of replacing Lua (because who likes Lua). I was gonna post this when the language was much more mature but I felt like reworking the CLI so I added an interpreter mode. That means you don't have to mess around with the stdlib and Lua linking and whatnot.
Once you download the jar from the releases, run it like this:
java -jar Rol-<version>.jar -i <input file>

Make sure -i is added otherwise it'll spit out a compiled Lua file.

HP User RPL, 14 bytes
Thanks Corvalis
"Hello, World!"

Alpha AXP machine language on OSF/1, 40 bytes
0x00:   d2200004    bsr a1, 0x14(zero)    # Set a1 to pointer of string
0x04:   6c6c6548    "Hello, World!\0\0\0"
0x08:   57202c6f
0x0c:   646c726f
0x10:   00000021
0x14:   43e09400    addq    zero, 0x4, v0 # Select write() syscall
0x18:   43e03410    addq    zero, 0x1, a0 # stdout
0x1c:   43e1b412    addq    zero, 0xd, a2 # string length
0x20:   00000083    call_pal    callsys   # write(1, str, len)
0x24:   6bfa8001    ret zero, (ra), 1     # return

To try this on a suitable machine or emulator, compile and run the following C program
int main[]={0xd2200004,0x6c6c6548,0x57202c6f,0x646c726f,0x21,
            0x43e09400,0x43e03410,0x43e1b412,0x83,0x6bfa8001};

Thunno 2, 2 bytes
kH

Attempt This Online!
Polyglots with Vyxal. Constant for "Hello, World!".
Thunno 2, 8 bytes
’Ƙ¥, «ʋ!

Attempt This Online!
Dictionary compressed string.

GAIA, 14 bytes
“Hello, World!

Try it online!

You need an ! at the end. Also, it seems to work without the trailing quote.

hyperscript, 27 24 bytes
init log 'Hello, World!'

Calls the log command when the document is initialized.

(,) 375 344 334 Chars or \$334\log_{256}(3)\approx66.17\$ Bytes
(()()(),()()()()()()())((),(()()())()()())((()),(())(())(()))(((())),((()))((()))(()))(,,,(((())))()())(()(),(((())))((()))())(,,,(()()))(,,,(()())(()()()),(),,()())(,,,(()())(()))(,,,((()))(())()()()())(,,,((()))()())(,,,(((())))(())(()()()))(,,,(()())(()))(,,,(()())(())()()())(,,,(()())(()()()))(,,,(((())))((())))(,,,((()))()()())

Can likely still be golfed a lot.
Tio

Commodore C64 BASIC (Non-competing/just for fun), 36 Tokenised BASIC bytes, 34 PETSCII characters
0LIST:REM"{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}HELLO, WORLD!

This uses a trick to hide a BASIC line, by starting a REM statement with a quotation mark, you may use the delete control character (CTRL+T) which is displayed as a reversed T character (see screen shot below). When you RUN the program, the line number, LIST and REM command are hidden by the text HELLO, WORLD!. You get the same output when you LIST the program too.

Wait, this is worse than the standard 0?"Hello, world!, codegolf-wise, right?

Why 0?"HELLO, WORLD! when one might as well just do ?"HELLO, WORLD! without the line number? I include it not because it's the best solution, but because it is possible within BASIC V2 on a Commodore C64. Also, I clearly marked this as non-competing and just for fun - so I assume that your question is entirely rhetorical.

Shasta v0.0.5, 24 bytes
(print["Hello, World!"])

Shasta is a new programming language I've been developing for the past couple of days, and I've finally got it to a state where I can start to answer some challenges on the site here. It is inspired by Lisp and Python, and transpiles to JavaScript. I'll update the header once the language gets a bit more stable; it's possible (though very unlikely) that this Hello World program won't work anymore in the future.
I haven't set up an online interpreter yet, so for now you can install Shasta off NPM with npm install --global shasta-lang@0.0.5, and run it via the CLI:
echo '(print["Hello, World!"])' | shasta-lang | node
Hello, World!

DEC VAX machine language on UNIX v8 or 4.3BSD, 40 39 bytes
00: 00 00                                 ;entry mask
02: dd 0d                pushl $0xd       ;len of string
04: df ef 10 00 00 00    pushal $0x1a     ;addr of string
0a: dd 01                pushl $0x1       ;file descriptor=1
0c: 9a 04 50             movzbl $0x4,%r0  ;select write() syscall
0f: fb 03 ef ff ff ff ff calls $3,0x15    ;call syscall
16: 04                   ret
17: bc 50                chmk %r0         ;syscall
19: 04                   ret
1a: 48 65 6c 6c 6f 2c 20 "Hello, World"
    57 6f 72 6c 64 21

The entry mask specifies which regs are saved and other runtime characteristics of the procedure. Because of the way syscalls work on VAX, the golfiest way to make one (as far I know) is a two step procedure. I have also overlapped the end of the "call" instruction with the start of the entry mask of the syscall procedure.
In honor of the 39th anniversary of mullender.c you can try out the above code by compiling and running the following C program on an actual or emulated VAX.
char main[]={0x00,0x00,0xdd,0x0d,0xdf,0xef,0x10,0x00,0x00,0x00,0xdd,0x01
,0x9a,0x04,0x50,0xfb,0x03,0xef,0xff,0xff,0xff,0xff,0x04,0xbc,0x50,0x04,
0x48,0x65,0x6c,0x6c,0x6f,0x2c,0x20,0x57,0x6f,0x72,0x6c,0x64,0x21};

Positionally, 80 bytes
/

        ^+     <
DH  !"! C ! K !Q!N!6! +N!K !K!
      ;<
       /  s    /

Try It Online!

Positionally, 153 81 bytes
/     \
  1    \       \

  -    <^
fI  I""em s p X!-pmm
      ;
   j      s    /

Try It Online!

Explanation
In contrast to many 2D-programming languages where the character itself signifies the command, Positionally differentiates itself by using the positions of non-whitespace characters to dictate the command executed. This unique approach effectively precludes the possibility of writing "flat" programs.
The language disregards all spaces, even those within strings, making output of the space in Hello, World! particularly challenging. As a workaround, the program inserts the string "emspX!-pmmfI (note this is overlaid on top of functional parts of the program) and then outputs it in reverse, decrementing each character's ASCII value by 1 to achieve the desired Hello, World!.

Nice! My original attempt was mostly a very cursed proof-of-concept, but it's cool to see a more golfed version.

@emanresuA, This is mostly a byproduct of the quine I am trying to create, pretty sure hello world can be made even shorter.

F#, 21 bytes
printf"Hello, World!"

Thanks for the comment @LegionMammal978!

This can be shortened to printf"Hello, World!" for a 21-byte solution.

C++, 59 bytes
#include <iostream>
int main(){std::cout<<"Hello, World!";}

Isn't the newline optional?

@UndefinedFunction try it. It will not work without a new line

Isn't printf smaller? #include <cstdio>?

@georgeunix My comment referred to a previous version, in which it read cout<<"Hello, World!\n". The \n was removed, since a newline was not required after the output.

Oh OK, sorry for that @UndefinedFunction

@LegionMammal978 no

Stackstack, 20 Bytes
This is a stack-based language not focused on golfing! Looks similar to Forth, and was made two years ago.
"Hello, World!"print

STATA, 17 bytes
di"Hello, World!"

Enema, 21 bytes
"!dlroW ,olleH"[DZBO]

How it works
"!dlroW ,olleH" Push those characters (including a null byte) on the stack.
[               Infinite loop:
  D               Duplicate the topmost element on the stack.
  Z               If it is non-zero, skip the next instruction.
    B             Break out of the loop.
  O             Output as a character.
]

Matlab / Octave 21 20 bytes
21 bytes:
disp 'Hello, World!'

Try it on ideone (using Octave).
Note that removing disp is not acceptable, as the output would be ans = Hello, World!.
20 bytes:
!echo Hello, World!

This works for Matlab on Windows, Linux or Mac.

disp"Hello, World!" is shorter.

@kvill Thanks! But that doesn't work in Matlab. I'll leave that to you to write an Octave answer, and I'll remove the "Octave" language from mine

Hm, I thought they shared more syntax and I had no matlab available for testing. Good to know!

dc, 16 bytes
[Hello, World!]p

I can't think of any way to get this one shorter.

Element, 17 bytes
Hello\,\ World\!`

The ` outputs the string, while the \s are used to escape out of other characters.

FALSE, 15 bytes
"Hello, World!"

Vimscript, 17 bytes
ec"Hello, World!"

You can remove the colon to save one byte ;)

Objective-C, 30 bytes
main(){puts("Hello, World!");}

Ada (GNAT), 54 bytes
procedure gnat.io.a is begin put("Hello, World!");end;

This trick is from anarchy golf: by defining your program in the GNAT.IO namespace, you have access to the put function, which is shorter than the usual way to print strings.

Curry, 26 bytes
main=putStr"Hello, World!"

Clojure, 22 bytes
(print"Hello, World!")

Betterave, 16 bytes
$"Hello, World!"

Betterave is unusual in that it has the whole "one character = one command" thing going on that many esolangs have, but it uses prefix notation, and the program is one big expression à la Scheme, as opposed to being tape- or stack-based. Here, $"Hello, World!" is just like a function call to print.

K, 18 bytes
`0:"Hello, World!"

I think you should try for every letter in the alphabet ;)

In some versions of K, you can just use "Hello, World!" as the entire program. I can't recall, but I believe it's either official K2 (NOT Kona, which doesn't print it; I think it's a K3 thing) or the official K5 (not sure about oK, though).

Frink, 23 bytes
println["Hello, World"]

I only know of this through my searches for programming apps in the Play Store.

TvmJIT, 29 bytes
(!call print "Hello, World!")

REBOL, 26 bytes
REBOL[]prin"Hello, World!"

REBOL scripts needs a valid header; the first seven bytes of this program are the simplest possible header. Then, prin prints a value without a trailing newline.

Dart, 31 bytes
main(){print("Hello, World!");}

Gema, 21 bytes
\A=Hello, World\!@end

(Without input it would wait forever without terminating. Hence the need for explicitly @end.)

Inform 6, 24 bytes
[Main;"Hello, World!";];

This must be compiled to Z-code, not Glulx.
Inform 6 has the neat feature that bare string literals are compiled into a print statement followed by a return true statement.

Muriel, 16 bytes
."Hello, World!"

O, 16 bytes
"Hello, World!"o

Try it online in the O Online IDE.

small s.c.r.i.p.t., 15 bytes
Hello\, World\!

Using the OpenCOBOL interpreter, you have to pass this code as a command-line argument. Reading the from a file does weird things.
I'm not entirely sure why, but this works when reading from a file:
Hello
\, World\!

0(nop^), 19 Bytes
1$(Hello, World!")`

Time to start completing the numbers :)
1                   # push a non zero to top of stack
 $                  # duplicate top of stack
  (              )  # Push characters to pointer address
   Hello, World!    # Hello, World!
                "   # Pop string and save
                  ` # Output string if top of stack not 0

LOLCODE, 35 bytes
HAI !
VISIBLE"Hello World!"
KTHXBYE

HAI ! initializes the code (just using HAI with a newline results
in error)
VISIBLE"Hello World!" prints Hello, World!
KTHXBYE ends the program.

It seems we already have a shorter LOLCODE answer (feel free to leave yours as well though if you want).

Ah - ok. I'll leave mine here for the purpose of having HAI and KTHXBYE.

~English revised, 21 bytes
Show "Hello, World!".

~English is not English, but looks like it.

REGXY, 16 bytes
//Hello, World!/

The implementation on the Esolang page generates Perl code, which will attempt to read from STDIN.
Input may (and has to) be empty for correct output, but STDIN has to be closed for the code to run.
Verification
$ perl -e "$(perl regxy.pl hello.xy)" <&-
Hello, World!

Snowman, 18 bytes
("Hello, World!"sP

Explanation
( sets variables a and f active. Then the string Hello, World is pushed to the first active variable, in this case, a. Then sP (String Print) prints the string from the first active variable with a string in it.

MoonScript, 20 bytes
print"Hello, World!"

BrainfuckXT, 16 bytes
{Hello, World!}$

{...} puts a string on the tape, and $ outputs it.

PureStack, 18 bytes
"Hello, World!"
!~

Pushes "Hello, World!" to the stack and prints it.

Kipple, 67 17 bytes
"Hello, World!">o

Sends the string to o using the preprocessor.

Loader, 22 bytes
printf "Hello, World!"

Microscript, 17 bytes
"!dlroW ,olleH"ah

Marbelous, 26 bytes
48656C6C6F2C20576F726C6421

Huh, I'm surprised no one has done Marbelous yet. There is not much to golf though: just list the 13 character codes in hexadecimal, to create one marble for each. As they fall off the grid, they're printed.

X-D, 81 Bytes
I can't be sure that this would work as I can't find an interpreter, so if someone can, that would be good :) <- gratuitous smiley
8-~~~~~>8P8;$;~~>;P;------>;-P;%$;-->;P:~~->:P:~<:-->:P8~>8P;P;-->;P%P;~<;>;P8>8P

An explanation of what I think should be happening
#                        Pointers:   8    ;    :    %
8-~~~~~>8P  # set 8 to 72, print 8  72
8;$         # copy 8 to ;                72
;~~>;P      # inc ; 29, print ;         101
;------>;-P # inc ; 7, print ;          108
;%$         # copy ; to %                         108
;-->;P      # inc ; 3, print ;          111
:~~->:P     # set : to 44, print :            44
:~<         # dec : 15                        29
:-->:P      # inc : 3, print :                32
8~>8P       # inc 8 15, print 8     87
;P          # print ;                   111
;-->;P      # inc ; 3, print ;          114
%P          # print %                             108
;~<         # dec ; 15                   99
;>;P        # inc ; 1, print ;          100
8>8P        # inc 8, print 8                  33

ISCOM, 15 bytes
"Hello, World!"

Groovy, 20 bytes
print"Hello, World!"

KimL, 22 bytes
io.out"Hello, World!"

The byte count contains a trailing linefeed.

Basil, 16 bytes
Meh.
"Hello, World!"o

Simple.

Perl 6, 18 bytes
say"Hello, World!"

I'm pretty sure this is as short as you can get, please let me know if there's any improvements that can be made.

say needs a space after though

Staq, 15 bytes
"Hello, World!"

Output:
Executing D:\codegolf\Staq Hello World codegolf.txt

Hello, World!

Execution complete.
>

MagiStack, 22 bytes
"!dlroW ,olleH"|,?0=_@

Note that the reference implementation will print a leading linefeed, because it reads the filename interactively. This is not part of language specification.
How it works
"!dlroW ,olleH"         Push those character on the stack (last on top).
               |        Set marker.
                ,       Print a character from the stack and pop it.
                 ?      Push the stack's length.
                  0=    If the length is zero:
                    _     End the program.
                     @  Go back to the marker.

Emoticon, 26 bytes
Esolangs page for Emoticon.
Hello, World! :-Q S:-P :-P

One or both of the Ps could be Qs instead. Hello, and World! are just treated as strings and added to the "current list". :-Q prints Hello, and removes it from the list. S:-P prints a space, and :-P prints World!. I don't see how I could golf this any further, and I'm making it CW, because it's essentially copied from the examples section of the docs.

I had a play arounf with there online interpretor and this appears to work Hello, World! :Q S::P :P and a couple shorter

@MickyT ah thanks, I'll have to test that tomorrow. The docs mentioned that there are 2-character emoticons, but they seemed to imply that the eyes were optional, not the noses. This makes much more sense though.

@MickyT I found this in the language spec: "These Emoticons output values from lists to Output Channels. Output channels are not lists, they are defined by the Interpreter and could be on screen areas, files, pipes and the like. Output Channels are implementation dependant. The Channel to which output should be printed is indicated by the nose of the Emoticon. By default screen print values should go to the channel -". Looking at the output of the interpreter, it seems like your code uses the : channel instead or - (which is STDOUT), so I think the code will have to stay as it is.

That makes sense

Hassium, 38 Bytes
Neat challenge! Love all the different submissions so far. Here is mine in
a language I wrote called Hassium.
func main(){println("Hello, World!");}

Run it online here

Using your online interpreter you can shorten it a bit using func main()println("Hello, World!")

OCaml, 30 bytes
print_string "Hello, World!";;

print_string"Hello, World!" also works, for 27 bytes. Try it online!

ABCD, 390 bytes
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAADDAAADBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBDBBBBBBBBBBBBDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAADAAADBBBBBBDBBBBBBBBDBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBDBBBBBBBBBBBBBBBBBBBBBBBD

Equivalent to +++++etc+++.+++++etc+++.+++++++..+++.-----etc
in brainfuck.

Dogless, 13 bytes
Hello, World!

There is no |, so the program just terminates and outputs itself.

Version, 37 bytes
A:OUTPUT="Hello, World!"
B:IGNORE="*"

The first line prints the string. The second line tells the interpreter to ignore all lines, to prevent an infinite loop.

UniBasic, 19 Bytes
CRT 'Hello, World!'

Windows Batch, 18 bytes
echo Hello, World!

We need to hide the prompt....

EXCON, 137 bytes
<<<^<<<^!:^<<^<<<^<^!:<<^<^<<^<^!!:^<^<^<^<<^<^!:<<^<^<<^!:<<<<<^!:^<^<^<<^<<^!:^<^<^<^<<^<^!:<^<<<^<^<^!:<<^<^<<^<^!:<<^<<<^<^!:^<<<<<^!

Simple bit-hacking.

Blank, 64 bytes
[33][100][108][114][111][87][32][44][111][108]{:}[101][72]{p}{@}

Hint: Read the interpreter / compiler to ensure that you use all features. This esolangs page, for example, used to exclude the p instruction.

A:;, 19 bytes
b:Hello, World!;p:b

Sets b to the string and prints it.

Stackstack, 21 bytes
"Hello, World!" print

print is the standard output mechanism.

tinyAll, 1 byte
Tinyall is a language that I've developed after this challenge was published.
It was written in a few hours, at 1AM.
The smallest valid example of an Hello, world! program was inspired by @Fatalize's answer. But it is too easy and only allows 1 syntax.
I've decided to do better:
f

This is the equivalent to Hf or H15. Low-case letters are considered numbers from 10 to 46(?).
H is the Hello, World! function, responsible for the output. Passing an argument, you can set specific bits to output a variation of the Hello, World! output.

You could also write like this:
Hf_

Or, with string expansion:
_"[:Hf]"

Or just plain:
_"Hello, World!"

And a dynamic example:
H:_

This one takes whatever input and outputs whatever version you decide it to. (By using :, the input has to be a number)

Execution example:

(function(window, undefined) {
 var funcs = {
  H:function(value) {
   return 'hH'[value&1]
    +'ello'
    +(value&2?',':'')
    +' '
    +('wW'[+!!(value&4)])
    +'orld'
    +(value&8?'!':'')
    +(value&16?'\n':'');
  },
  I:function(value, data){
   return data.input;
  },
  '_':function(value, data){
   var tmp = data.out + (value === undefined ? data.last : value);
   data.vars[';'] = data.out = tmp;
   return tmp;
  },
  V:function(value){
   return get_value(value);
  },
  P:function(value){
   return value;
  }
 };

 var expand_string = function(value, data){

  return value.replace(
   /\[:(?:([A-Z_])(.)?|([^A-Z_'"]))\]/g,
   function(_, func, arg, value){
    if(func)
    {
     return funcs[func](get_value(arg, data, true), data);
    }
    else
    {
     return get_value(value, data, true)
    }
   }
  );

 };

 var get_value = function(value, data, recursion) {

  if(value === null || value === undefined || value === ' ')
  {
   return undefined;
  }

  var x = (value || '').toString();

  if(/^\-?\d+$/.test(x))
  {
   //returns a number
   return Function('return ' + x)();
  }
  else if(/^[a-z]$/.test(x))
  {
   //returns a number between 10-43
   return (x in data.vars) ? data.vars[x] : x.charCodeAt(0) - 87;
  }
  else if(x[0] == '\'')
  {
   return x[1];
  }
  else if(x[0] == '"' && x.length >= 2)
  {
   var sub = x.substr(1, x.length - 2);

   return recursion ? sub : expand_string(sub, data);
  }
  else
  {
   return data.vars[x];
  }
 };

 var noop = function(){};

 window.tinyAll=function(code, input) {
  var data = {
   out: '',
   last: 0,
   input: input || 0,
   vars: {
    '|':'0.3',
    ':':input || 0,
    ';':0
   }
  };

  if(!code || /^[a-z\d]$/.test(code))
  {
   return funcs.H(get_value(code, {}));
  }

  code.toString().replace(
   // /(?:([^A-Z_:'"])=)?([A-Z_])(?::('.|"[^"]*"|-?\d+|.))?/g,
   /(?:([^A-Z_'"])=)?([A-Z_])(?:('.|"[^"]*"|-?\d+|[^A-Z_'"]))?/g,
   function(_, name, func, value){

    data.vars[name || ':'] = data.last = (funcs[func] || noop)( value ? get_value(value, data) : data.last, data);

    return '';
   }
  );

  return data.out || 0;
 };
})(Function('return this')());

alert(tinyAll('_"\'Hf\' produces: \'[:Hf]\'"'));

This is the original version. I'll post a new version of the code, as soon as I have time to publish on Github.

Thue, 24 bytes
a::=~Hello, World!
::=
a

When a is encountered in the last line, the string is printed.

Aeolbonn, 14 bytes
:Hello, World!

: is the standard output mechanism.

Amiga E, 38 bytes
PROC main() IS WriteF('Hello, World!')

WriteF is the standard output mechanism.

96, 44 bytes
72,101,108:,@,111,44,32,87,111,114,@,100,33"

Uses the accumulator to store the L.

[], 20 bytes
(({<[Hello, World!})

Don't ask me how this works.

How does this work?

@NieDzejkob Good question!

Here is some documentation on how this works. It works because (({<x) prints the value of x. What remains is to convert "Hello, World!" into something printable by putting it in the declareDataX function [x} like [Hello, World!}. Therefore the program is (({<[Hello, World!}). At least I think that is how it works.

Sprects, 14 bytes
.Hello, World!

MUMPS, 17 bytes
w "Hello, World!"

Not terribly exciting, but there you have it.

http://i.imgur.com/RG0BS1U.gif

Processing, 23 bytes
print("Hello, World!");

Well, that's pretty much it!

jq, 17 bytes
(15 characters code + 2 characters command line options.)
"Hello, World!"

(jq being a JSON processor filter, for this task you have to specify the -n (null input) and -r (raw output) options.)
Sample run:
bash-4.3$ jq -nr '"Hello, World!"'
Hello, World!

On-line test (Passing -r through URL is not supported – check Raw Output yourself.)

G*, 15 bytes
p Hello, World!

Pretty simple.

Augeas, 42 bytes
module A=let _=print_string"Hello, World!"

I'm writing this because ℝaphink won't.

If it got someone else to post an Augeas answer, I'm happy with that :-)

Stringy, 17 bytes
(Hello, World!);p

Pip, 15 bytes
"Hello, World!"

Straightforward. Any expression at the end of the program is auto-printed.

Out of curiosity, dose Pip have auto-closing end quotes? Or is that impractical for an infix language?

@ConorO'Brien It would certainly have been possible, I just decided I didn't like it for aesthetic reasons.

Fair enough. :D

Aysolang - 30 23 bytes
{dlrow, olleH};
l0=?;o

Explaination:
{dlrow, olleH}; ~~ Push the ascii values of "Hello, world" on the stack, reversed and terminate the line
l0=             ~~ Check if the length equals zero
?;o             ~~ If it equals zero, terminate. Otherwise, output the top of the stack as a character.

Chaîne, 13 bytes
Hello, World!

Everything is an implicit string, and everything is implicit output.

Ooh, fancy i-like character~ Also an interesting language.

, 19 17 bytes
ô`Hello, World!`

The “” string construction actually ends up using more bytes.

Yay, someone else is using my language! You can do ô\Hello, world`` too.

ShapeScript, 15 bytes
'Hello, World!'

I created ShapeScript for this competition. The interpreter on GitHub has a slightly modified syntax and better I/O (none of which are required in this answer).
Try it online!

Microscript II, 15 bytes
"Hello, World!"

DStack, 21 bytes
@0
Hello, World!
@
ad

SuperCollider, 27 bytes
"Hello, World!".post;1.exit

Where is the documentation for SuperCollider?

@zyabin101 http://supercollider.github.io/

It's not an esolang.

Geom++, 17 bytes
" Hello, World! "

Yes, the spaces around the string are necessary.

Joy, 24 bytes
"Hello, World!"putchars.

You forgot the exclamation mark!

Lines, 13 bytes
Hello, World!

There are no control characters, so the string is just output.

Gray Snail, 22 bytes
OUTPUT "Hello, World!"

OUTPUT just outputs the string.

Jumper, 59 bytes
=72>=101>=108>=108>=111>=44>=32>=87>=111>=114>=108>=100>=33

Milky Way 1.0.0, 16 bytes
"Hello, World!"!

or
"Hello, World!">

Explanation
"Hello, World!"   # push "Hello, World!" to the stack
               !  # output the TOS

or
"Hello, World!"   # push "Hello, World!" to the stack
               >  # rotate the stack rightward.
                    if nothing is output manually,
                    the bottom stack item is output

Elixir, 22 bytes
IO.puts"Hello, World!"

Dirst, 21 bytes
dss_Hello, World!.txt

Note: this must be run in a system where ! is allowed in filenames.

Pig, 27 bytes
/dev/stdoutPIGHello, World!

Requires a Unix-like OS to run. Pig is a simple language in which a program is a filename, followed by PIG, followed by anything else, which writes the string to the file specified by the filename. In this case, I use the tactic of writing the output to /dev/stdout, outputting the string. /dev/tty outputs the string, but it requires a console window to work, and doesn't pipe output correctly.

Not a programming language.

C, 32 bytes
main(){printf("Hello, World!");}

Tested on C99 Strict, compiler will generate a warning that there is no return-type, and int is assumed.

What actually happens in most environments is that the return value from the last printf is left in the register used for return values.

Quote Reference
In our case the printf("Hello, World!") is the only statement in our program, which will set 13 in the registry for return values.
In most environments, EXIT_FAILURE is usually 1 as in gcc, which means that on most environments this will not write to STDERR.

It seems we already have a shorter C solution. Your elaboration is nice though, so I guess it's your call whether you keep this answer or not.

@MartinBüttner is it okay to provide an answer that has a requirement on how to compile or a specific file name ?

Answers that only work with specific compilers are fine (for the purposes of code golf here, languages are actually defined by their implementations). Specific command-line options and file names are legitimate too but need to be added to the byte count.

Pilot, 15 bytes
t:Hello, World!

(no trailing newline is ok for the Pilot implementation I used)

CP/M nostalgia...
A>type hello.plt
t:Hello, World!
A>do pilot/pr hello
SuperSUB V1.1

A>: SUBMIT PILOT/P WITH REAL TYPE SUPPORT
A>PILOT/P HELLO
PILOT/P version 2.5, 02/26/84
READING FROM HELLO.PLT
WRITING TO   HELLO.PAS
Translating: HELLO

A>ERA OLD.HDR
No file
A>REN OLD.HDR=PILOT/P.HDR
A>REN PILOT/P.HDR=PILOT/PR.HDR
A>PASCAL HELLO
InterSystems Pascal v - 4.0
HELLO        1---
VLENGTH     27-
MEMAVAIL    28--
SETLENGT    30-
LENGTH      31-
INDEX       33-
POS         34-
UCASE       35-
LCASE       36-
DELETE      37-
COPY        38-
INSERT      39--
REPLACE     40-
CONCAT      41-
STR         42-
IVALUE      43-
HALT        44-
ISALPHA     45-
ISUPPER     46-
ISLOWER     47-
ISDIGIT     48-
ISSPACE     49--
TOUPPER     50-
TOLOWER     51-
KEYIN       52-
KEYBOARD    53-
DWRITE      54-
CONSTAT     55-
CONCHAR     56-
GOTOXY      57-
VAL         58-
RANDOM      59--
RND         63-
RANDOMIZ    65-
INITIALI    69-----
WAIT       102---
MATCH      124-------
HELLO      185-
0 compilation error(s).

A>ERA HELLO.LST
A>REN PILOT/PR.HDR=PILOT/P.HDR
A>REN PILOT/P.HDR=OLD.HDR
A>ASMBL MAIN,HELLO/REL
Pascal/Z run-time support interface ASMBLE v-7d

0 errors.  312 symbols generated.  Space for 2819 more symbols.
4275 characters are stored in 44 macros.
1680 bytes of program code.

A>ERA HELLO.SRC
A>LINK /N:HELLO CHAIN HELLO ASL/S/E
LINK version 2b
Load mode
Generate a COM file
Lo = 0100   Hi = 1A32   Start = 0172   Save  26 blocks

A>ERA HELLO.REL
A>ERA HELLO.PAS
A>hello
Hello, World!

A>_

COMAL, 20 bytes
1print"Hello, World!

CP/M nostalgia...
A>comal

         (C) Copyright 1987
  COMAL Users Group, U.S.A. Limited

1print"Hello, World!
run
Hello, World!

End of program
bye

A>_

Algol-M, 36 bytes
BEGIN
WRITE("Hello, World!");
END

CP/M nostalgia...
B>type hello.alg
BEGIN
WRITE("Hello, World!");
END

B>algolm hello
ALGOL-M COMPILER VERS 1.1
   0 ERROR(S) DETECTED

B>runalg hello
ALGOL-M INTERPRETER-VERS 1.0

Hello, World!

B>_

A problem?
There is more output than just "Hello, World!" but that output is not caused by the program itself, it is caused by the interpreter.

In this challenge, not even extra interpreter output is allowed. Is there a way to disable it?

@Martin Büttner: Hey chef... I've no problem deleting this solution if that not-by-my-program-output really is a probem... or use your moderator magic power and delete it... definitely my life does not depend on this solution... ;-)

Befalse, 41 bytes
I want to learn this language, but it's so confusing ):
0"!dlrow olleH"!/$?\
                \. /

Demo (paste into the the box and click "Show", then click "Run".)

SPL, 91 bytes
File hello.spl:
PROGRAM h;BYTE w='Hello, World!$';PROCEDURE BDOS(WORD f,s);EXTERNAL;BEGIN BDOS(9,@w) END h.

With some CRLFs (99 bytes):
PROGRAM h;
BYTE w='Hello, World!$';
PROCEDURE BDOS(WORD f,s);EXTERNAL;
BEGIN
BDOS(9,@w)
END h.

(both without crlf after last line)

CP/M nostalgia...
E>type hello.spl
PROGRAM h;BYTE w='Hello, World!$';PROCEDURE BDOS(WORD f,s);EXTERNAL;BEGIN BDOS(9,@w) END h.
E>do c hello
SuperSUB V1.1

E>; COMPILE AN SPL PROGRAM
E>SPL HELLO

SPL V-1.03.03.10 (17-Dec-06 13:41:11)
No errors. Code = 31. Free memory = 30081.

E>L80 HELLO,HELLO/N/E

Link-80  3.44  09-Dec-81  Copyright (c) 1981 Microsoft

Data    0103    01D6    <  211>

46887 Bytes Free
[0111   01D6        1]

E>ERA HELLO.REL
E>hello
Hello, World!
E> _

Can the downvoter please explain why downvoting was needed? Can it be done shorter in SPL?

Genie, 28 bytes
File hello.gs:
init
        print "Hello, World!"

(tab indented, needs final newline)
Compile & run:
$ valac hello.gs
$ ./hello
Hello, World!

Vala, 36 bytes
File hello.vala:
void main(){print("Hello, World!");}

...without trailing newline.
After a diet suggested by @ASCII-only.
Try it online!

Vala, 42 bytes
Yayyyy!!! 42!!! \o/
File hello.vala:
void main(){stdout.puts("Hello, World!");}

...without trailing newline.
Run:
$ valac hello.vala
$ ./hello
Hello, World!

You can just use print

WhoScript, 19 bytes
1"Hello, World!";pf

Not nearly as much fun as the full version:
# 48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21
@ push the ASCII values of the characters "Hello, World!" to the stack

psychic_paper flush
@ print all values on the stack as ASCII characters

Freelang, 291 bytes
A lot of whitespace, but it's an assembly language for a virtual machine. I'm pretty sure this won't compile without the indents.
H{
  ." Hello world! " p
  halt
  : p ( s -- )
    [@] 4 * swap incw swap
    w:
      go[<=0] :e
        dec swap [@b]
          go[==0] :s
            writorb ::z
            go :n
        s:
          drop
        n:
          inc swap
          go :w
    e:
      drop2
  ;
  z: halt
}H

o:XML, 48 bytes
From the web site:

o:XML is a complete object oriented programming language, with features including polymorphism, function overloading, exception handling, threads and more. The syntax is fully compliant XML. With o:XML, object-oriented paradigms can be leveraged to the maximum, while data and code remains in a standard format. With o:XML there is no 'impedance mismatch' when developing XML web-applications, tools and systems. Furthermore o:XML integrates seamlessly with most popular Java platforms, including Java Servlets, Struts, Ant, BSF and Spring 2.0.

This program comes from http://www.xml.com/pub/a/2004/07/21/oxml.html
<?xml version="1.0"?>
<o:do>Hello, World!</o:do>

SuperX++, 37 bytes
From the web site:

Superx++ is an object-oriented language that is entirely based on XML's syntactical structure. Superx++ conforms with the XML version 1.0 specification as published on the W3C web site. Programming in XML itself has great potential and Superx++ pushes the envelope!

This program comes from http://xplusplus.sourceforge.net/FAQ.htm#hellow
<xpp><xout>Hello, World!</xout></xpp>

lang5, 17 bytes
lang5 is a combination of APL and Forth (Hello World doesn't show off any of the APL bits)
"Hello, World!" .

Nemerle, 38 bytes
System.Console.Write("Hello, World!");

Description from https://en.wikipedia.org/wiki/Nemerle
Nemerle's most notable feature is the ability to mix styles of programming that are object-oriented and functional. Programs may be structured using object-oriented concepts such as classes and namespaces, while methods can (optionally) be written in a functional style. Other notable features include:

strong type inference
a flexible metaprogramming subsystem (using macros)
full support for object-oriented programming (OOP), in the style of C#, Java, and C++
full support for functional programming, in the style of ML, OCaml, and Haskell, with these features:

higher-order functions
pattern matching
algebraic types
local functions
tuples and anonymous types
partial application of functions

The metaprogramming system allows for great compiler extensibility, embedding domain-specific languages, partial evaluation, and aspect-oriented programming, taking a high-level approach to lift as much of the burden as possible from programmers. The language combines all Common Language Infrastructure (CLI) standard features, including parametric polymorphism, lambdas, extension methods etc. Accessing the libraries included in the .NET or Mono platforms is as easy as in C#.

Mouse16, 16 bytes
I finally made it turing-complete!
"Hello, World!"!

Boring, I know.
If you want somewhat interesting, then there's this, which runs Python from inside Mouse, for 31 bytes:
"!!PY!!print('Hello, World!')"`

The to-be interesting bits of Mouse aren't implemented yet, but we have control structs, so...

A-Ray, 16 bytes
Any new language should be put here just for the sake of being put here...
p"Hello, World!"

Falcon, 16 bytes
I'm sad that the last update to this language was in 2010 :( it looks so cool! it's still indev!!
>"Hello, World!"

It gets its syntax from Python and PHP, most noticeably.

Pike, 35 bytes
A fast OOP scripting language with familiar C-style syntax.
int main(){write("Hello, World!");}

The optional return 0; is left off, because it runs without it.
In the REPL, the main declaration can be left off.
Pythonish, but with C syntax. OO-enabled, and also inherits from PHP (the good parts), Perl and (duh) C/C++, but Pike isn't halfassed about OOP like C++ is.

This can be compiled into ANSI C or C++ with a #define (and the #include, for standards compilance) for 113 bytes:
#ifndef __PIKE__
#include<stdio.h>
#define write(x) printf(x)
#endif
int main(){write("Hello, World!");return 0;}

No warnings with gcc -Wall -pedantic! Only a few more defines are needed to make almost any Pike into ANSI C. :D

Pylons, 16
Toggles string mode with " and then pushes "Hello, World!" to the stack, then uses c to print the whole stack as a string.
"Hello, World!"c

For 14 bytes, thought possibly cheating, so it's not my main answer,
c

with Hello, World! as a command line arg.
I don't have an online interpreter yet, but if you download the repo and pass the command line args to main.py and the program to stdin, it'll run.

Y, 16 bytes
Try it here!
"Hello, World!"p

Or
"Hello, World!"g

The former prints everything, and the latter prints one thing. In each case, the single entity on the stack is the string "Hello, World!".

Quetzalcoatl 17 15 bytes
"Hello, World!"

EDIT
I completely redesigned the language. The program pushes "Hello, World!" to stack, and implicitly prints.

P.S. I wrote Quetzalcoatl.

So you added ::. Does printing with slicing like this a=[1];::a[::] still work?

Yes it does. I specifically made sure it did. I just replace :: with print, and [print with [:: before I use exec. I am just assuming nobody makes arrays out of print statements, like [print 'a', print 'b'].

What if :: is within a string or two? Like exec"exec'print \"::\" ' "?

If the :: is in  a string, you have to escape it like so: print "\::".

I'd probably rather use Python just for the simplicity. It's more well-known.

bAdkOde, 59 bytes
I modified the example given on the language's website. Pushes the ASCII values in reverse order, then loops to print them.
)0)33)100)108)114)111)87)32)44)111)108)108)101)72(a{!a"a(a}

ForceLang, 24 bytes
io.write "Hello, World!"

Or, which is the same length:
gui.show "Hello, World!"

Looks like Lua. Isn't Lua, is ForceLang.

Reng v.1, 22 bytes
I proudly present to you my new 2D language, Reng! It's a lot like ><>, and many of the commands are similar. However, Reng features a lot of more, erm, features. Here is the code!
"!dlroW ,olleH"!|o?!|~

This pushes each of the character codes in the string !dlroW ,olleH first. Then, ! jumps into a loop. o outputs a charcter, and ? activates the next character iff the top of the stack is zero. This does not happen untill there are no characters left. When this happens, the mirror is skipped and the end character is met, ~.
Here is a visual representation of the code, which can be found here:

Cy, 21 18 bytes
"Hello, World!" :<

Cy is a new language I just made. It is stack-based/postfix, so the string "Hello, World!" must be pushed to the stack, then output it with the printing shortcut :<.
This is the first language I have made that was not inspired by code golf, but of course I'm still going to post in it.

Come Here, 19 bytes
TELL"Hello, World!"

-4 removing the NEXT, trailing newline is optional.

Mathcad, 18 bytes #
(or 15 bytes or 13 bytes depending upon one's tastes)

18 bytes would seem to be more in keeping with the spirit of the game, in that the user only has to type "s=" to get the answer, whereas the other two options involve the user actually typing Hello, World! themselves.
However, such considerations can get a little confusing sometimes in Mathcad, as the "source" file is also normally the "stdout".  This is because the Mathcad allows text, mathematical expressions, programs, plots and results to be mixed on the same worksheet (it's often helpful to regard Mathcad as a virtual whiteboard or document with live expressions).

Mmmm(), 1583 bytes
mmm=m[mm=m[m.m()].m(m.m())].m();mmmm=mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m())))));mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m(mmm.m())))))))))))))))));mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();m[mmmm].m(mmm.m());mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmmmm=mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmmmmmmm=mmm.m();m[mmmm].m(mmm.m());mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmmmmm=mmm.m();m[mmmm].m(mmmmmm);m[mmmm].m(mmmmmm);mmm.m();mmm.m();mmmmmmm=mmm.m();m[mmmm].m(mmmmmmm);mmm.m();mmm.m();mmmmmmmmm=mmm.m();mmm=m[mm].m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmmmmmmmmm=mmm.m();mmmmmmmmmmm=mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();mmm.m();m[mmmm].m(mmm.m());m[mmmm].m(mmmmmmmmmm);m[mmmm].m(mmmmm);m[mmmm].m(mmmmmmm);m[mmmm].m(mmmmmmmmm);m[mmmm].m(mmmmmm);m[mmmm].m(mmmmmmmm);m[mmmm].m(mmmmmmmmmmm)

A semi-golfed version of the "Hello, World!" program I wrote for the esolangs article a while back.

Pylongolf, 16 bytes
"Hello, World!"~

Push Hello, World! into the stack then print it.

Constant, 115 bytes
ppp*eee-pP;_fao*R;_fo+pp;_coo+p;_fo;eec*ppc+ef;_o-ppppf;_oZ+eeeepc;_o+eeef*pf;_o+pf;_o-pec;_o
-eeef;_ozeeef*pc+lf;_o

(the newline is unnecessary) Ungolfed:
ppp * eee-pP;
_fao * R;
_fo + pp;
_coo + p;
_fo;
eec * ppc + ef;
_o-ppppf;
_oZ + eeeepc;
_o + eeef * pf;
_o + pf;
_o-pec;
_o-eeef;
_ozeeef * pc + lf;
_o;

Try it out here!
This is a very natural program, except that numbers are not composed of the conventional digits, but rather constants such as p (pi) and e (euler's number). _ is the last expression, f is floor, c is ceil, and o is character output.

Nice answer.  Constant looks almost as weird as NTFJ.

@EasterlyIrk Then my mission has been accomplished. ^_^

META, 410 bytes
Try it here!
vXKZELI:{>.>:<.^;>,<v.^;;v.>>;<<^;v.v.^^;}{v.>:<.^;>,<v.^;;v.>>;<<^;v.v<;>^^;}{v.>::<.^;>,<v.^;;v.>>;<<^;v.v:^^;}
WJSM
NT
{fv.>::<.^;>,<v.^;;v.>>;<<^;v.>>;<<v^^;}>;<.>>!{v<<.>:<.^;>,<v.^;;v.>>;<<^;v.v<;>^^;}{v.>:<.^;>,<v.^;;v.>>;<<^;v.v.^^;}{v.>:<.^;>,<v.^;;v.>>;<<^;v.v.^^;}>>>.>;>;<<<<.>>.<<<{v.>::<.^;>,<v.^;;v.>>;<<^;v.v:^^;}{v.>:<.^;>,<v.^;;v.>>;<<^;v.v.^^;}{v..^;v..^;;>,<v.^;;v.>>;^<<;v.v.^^;}v>:<^.vvv?

This is another heckuva program. You want to know what it does, I'm sure. First, here's a nicer-looking version:
vXKZELI:{>.>:<.^;>,<v.^;;v.>>;<<^;v.v.^^;}{v.>:<.^;>,<v.^;;v.>>;<<^;v.v<;>^^;}{v.>::<.^;>,<
WJSMv.^;;v.>>;<<^;v.v:^^;}{v.>::<.^;>,<v.^;;v.>>;<<^;v.>>;<<v^^;}>;<.>>!{v<<.>:<.^;>,<v.^;;
NTv.>>;<<^;v.v<;>^^;}{v.>:<.^;>,<v.^;;v.>>;<<^;v.v.^^;}{v.>:<.^;>,<v.^;;v.>>;<<^;v.v.^^;}>>
>f.>;>;<<<<.>>.<<<{v.>::<.^;>,<v.^;;v.>>;<<^;v.v:^^;}{v.>:<.^;>,<v.^;;v.>>;<<^;v.v.^^;}{v..
^;v..^;;>,<v.^;;v.>>;^<<;v.v.^^;}v>:<^.vvv?

The basis of META is that it selects characters from the source code and performs operations of them. ><^v move the selection pointer around, {} allow for an extra level of eval and :;.,!? perform 6 different operations.
Let c be the character in question, and @c be its charcode.

: yields atob(atob(c + c + "==") + c + "==")
; yields atob(c + c + "==")
. yields char(127 - @atob(c + c + "=="))
, yields atob(c + char(127 - @c) + "==")
! yields char(@c >> 2 ^ 94)
? yields char((@c * 3 >> 3) + (@c >> 5))

Each time a char is yielded, it's pushed to a string, which is eval'd, then eval'd again.
The charset yielded by each character is not complete, so we cannot simply use these characters. The use of {} is mandatory for a lot of characters, which are constructed in a JSF**k-esque way.
A full explanation will take a ridiculously long time, and now I have to breathe some nice air.

Are you sure this is META, not .kill() Jr.?

Molecule, 24 bytes (UTF-16)
"ৣ͢ҁᚇь͚ᕲ"C

Molecule files written must be written in UTF-16 for it to properly work.
This basically uses the string compression method.

Pyke, 14 bytes
"Hello, World!

Try it here!

Batsh, 23 bytes
print("Hello, World!");

Try it online!
One-sentence description
Batsh is a language which compiles to bash and Windows Batch, thereby providing effortless cross-platform support for shell scripts, without additional dependencies.

Auo, 21 bytes
i.o:['Hello, World!']

Grin, 15 bytes
(Hello, World!)

Grin is a BF-based language that aims to make it slightly less of a Turing Tarpit.

APL, 15 bytes
'Hello, World!'

In APL, the last value is printed, so the hello world is obvious.

ABCD, 366 bytes
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAADDAAADBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBDBBBBBBBBBBBBDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAADAAADBBBBBBDBBBBBBBBDBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBD

Proof (note that I'm actually using the interpreter of ABCD)

Golisp, 21 bytes
write@"Hello, World!"

Equivalent to write["Hello, World!"], but shorter.

scratchblocks2, 33 bytes
when gf clicked
say[Hello, World!

BruhScript, 28 bytes
I take the bytecount of the encoded version.
Source:
«Hello, World!

Encoded:
0000000: 007e 002f 0008 0018 0018 000e 0056 0005  .~./.........V..
0000010: 0021 000e 0009 0018 0012 0044            .!.........D

This insane count of NUL bytes is because the encoding of BruhScript is a 16-bit encoding.
This code is really simple. A block (string literal, lambda, etc...) don't need to be terminated at the end of file.
EDIT: BruhScript print every thing on the stack at the end of the program, so the print function is not needed

Silicon, 15 bytes
"Hello, World!"

Everything in between the quotes are pushed onto the stack. Output is implicit, so no output command is needed.

Gopher, 48 Bytes
Hello World (42 Characters)
&++<'×<&÷+<^-<<×-<#!+<$@-<&@<×-<@++<@<.!<=

Hello, World (45 Characters)
&++<'×<&÷+<^-<<×-<#÷+<!×<$@-<&@<×-<@++<@<.!<=

Hello, World! (50 Characters)
&++<'×<?^×+<^-<<×-<#÷+<@÷<'?^-<?^<×-<÷--<@<.!-<+<=

Hello, World! (48 Characters)
&++<'×<&÷+<^-<<×-<#÷+<!×<$@-<&@<×-<@++<@<.!-<+<=

Click Here to Run the Code
This is an esolang I created myself, Not strictly designed for golfing, But it can be fun
As far as I am aware, This is also the shortest Hello World in Gopher, Prove me wrong thoughIt'll help me improve the optimiser I built for it!

hashmap, 15 bytes
"Hello, World!"

Just push Hello, World!

Kipple, 55 bytes
33>o<100 108>o<114 111>o<87 32>o<44 111>o<108>o<101o<72

Shorter answer here. This, however, is supporter by each and every intepreter of the language. The other one uses ", which does not have full portability between interpreters.

OPL-32, 33 bytes
...see Open Programming Language.
proc m:
print"Hello, World!"
endp

(no trailing newline)
Tested on Nokia Communicator 9300 with opl-1.56.

Standard ML, 20 bytes
print"Hello, World!"

This works with Moscow ML by calling mosml hello.sml or with Standard ML of New Jersey and sml hello.sml. In both cases an interactive session is started and Hello, World! is printed.
Inside a running session print"Hello, World!"; produces the desired output. The ; is needed to tell the interpreter to evaluate the expression.

For a compiled version
val _=print"Hello, World!"

works with mosmlc and MLton. Try it online!
However, MLton appears to accept interpreter-style programs too, so
print"Hello, World!";

works with a trailing ;. Try it online!

Which implementation does this use? MLton appears to require a ;.

@Dennis This works with the Moscow ML interpreter, that is calling mosml hello.sml starts the interactive interpreter and prints Hello, World!. For a compiled version with mosmlc a leading val _= appears to needed. I'll edit the post for clarification. Thanks for adding Standard ML to TIO!

Rews, 14 CP437 bytes
ïHello, World!

Explanation
ïHello, World! Insert in the buffer the text "Hello, World!" (the ¿ is not needed at the end of the program)
               Implicit output

This is UTF-8 bytes--and encoded in CP437, I believe it's 16. But only if your interpreter supports reading the encoding.

@CᴏɴᴏʀO'Bʀɪᴇɴ The Rews interpreter support CP437, and I'll fix the bytecount

PostScript, 16 bytes
(Hello, World!)=

s-lang, 18 bytes
Literally replaces "nothing" with "Hello, World!" (s-lang is not really meant to create strings, just modify them).
t[][Hello, World!]

t - replace function

Try it here

Maple, 16 bytes
"Hello, World!";

BrainCurses, 42 bytes
'!!'d!'l!'r!'o!'W!' !',!'o!'l!!'e!'H![$@_]

You can find an interpreter here, written by yours truly. This is part of my project to implement many of the unimplemented languages on esolangs.
Running & output
λ node BrainCurses.js HW.txt
Hello, World!

Gaot++, 1349 1167 690 bytes
baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bleeeeeeeeeeeeet bleeeeeeeeeet baaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bleet bleeeeeeeeeeeeet bleeeeeeeeeet baaaaaaaa bleet bleeeeeeeeeeeeet bleeeeeeeeeet bleeeeeeeeeeeeet bleeeeeeeeeet baaaa bleet bleeeeeeeeeet baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bleeeeeeeeeeeeet bleeeeeeeeeeeeet bleeeeeeeeeet baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bleeeeeeeeeet bleet baa bleeet bleeeeeeeeeeeeet bleeeeeeeeeet baaaaaaaaaaaaaa bleet bleeeeeeeeeeeeet baaaaaaaaa bleet bleeeeeeeeeeeeet baaaa bleet bleeeeeeeeeeeeet bleeeeeeeeeet baaaa bleet bleeeeeeeeeet bleeeeeeeeeet bleeeeeeeeeet baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bleeeeeeeeeet

Thanks to LeakyNun for having insanely golfed it
Compressed code:
73a 13e 10e 30a 2e 13e 10e 8a 2e 13e 10e 13e 10e 4a 2e 10e 45a 13e 13e 10e 33a 10e 2e 2a 3e 13e 10e 14a 2e 13e 9a 2e 13e 4a 2e 13e 10e 4a 2e 10e 10e 10e 34a 10e

This isn't working for me. It prints Hello,, then errors with ValueError: chr() arg not in range(256).

MemeGolf, 570 bytes
Yet another strange esolang from me
jQuery.Outgolf Dennis by 72 bytes.
jQuery.44
jQuery.Outgolf Dennis by 29 bytes.
jQuery.44
jQuery.Outgolf Dennis by 7 bytes.
jQuery.44
jQuery.44
jQuery.Outgolf Dennis by 3 bytes.
jQuery.44
jQuery.Juice avocado for 67 minutes.
jQuery.44
jQuery.Juice avocado for 12 minutes.
jQuery.44
jQuery.Outgolf Dennis by 55 bytes.
jQuery.44
jQuery.Outgolf Dennis by 24 bytes.
jQuery.44
jQuery.Outgolf Dennis by 3 bytes.
jQuery.44
jQuery.Juice avocado for 6 minutes.
jQuery.44
jQuery.Juice avocado for 8 minutes.
jQuery.44
jQuery.Juice avocado for 67 minutes.
jQuery.44
jQuery.HE COMES

Outgolf Dennis by n bytes. add n to the accumulator, Juice avocado for n minutes. substract n from the accumulator, 44 print the value of the accumulator as a character and HE COMES terminate the program.

Needs more JQuery

@BusinessCat The correct orthography is jQuery

Neoscript, 28 bytes
console:log("Hello, World!")

PyMin, 4 bytes
»Ħ

Body must be at least 30 characters; you entered 18.

SQF, 25 bytes
systemChat"Hello, World!"

Not sure if this qualifies as STDOUT, as to write to actual STDOUT the ArmA engine would have to to the writing, but the systemChat log is the closest thing SQF has to a standard output stream.

Link to SQF? (filler text)

@zyabin101 https://community.bistudio.com/wiki/SQF_syntax

MiniStringFuck, 1326 bytes
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.

Here, I present my new creation, MSF- (yes, MSF with a -, it's not Meta Server Fault here.) It's impractical for golfing, but it has 2 characters.
I am the winner on this language; you can't golf it more. Here are the two operators:

+: Add 1 to acc. If acc = 256, acc = 0.
.: Output acc as ASCII.

On the esolang page, I have, besides the interpreter (i.e. decoder), a generator (i.e. encoder) and an optimizer/golfer (i.e. compressor).
Unfortunately, this language doesn't support Unicode (yet).

If you support Unicode, wrapping would need 16777216 +, which is a bit long

Straw, 2 bytes
->

or
~>

Straw have 2 stacks. The first is initialized with a empty string, the second with Hello, World!.
~ toggle the active stack and - pop an item from the inactive stack and push it onthe active stack and > is the print command.

Dialpha bytecode, 44 bytes
Bytecode in Base64:
2voBAAEhAWQBbAFyAW8BVwEgASwBbwFsAWwBZQFIBQ8qAAAAHgseAAAAHwA=

Assembly code:
push8 0
"Hello, World!"
:loop
dup
jiz end
putc
jump loop
:end
flush
halt

How does the string get pushed to the stack?

@ConorO'Brien "<string>" reverse the string and push each character on the stack

CILOS, 43 bytes
int main(){__silos_print("Hello, World!");}

CILOS is a subset of C99 compiling to SILOS.

Lolo, 396 bytes
Something I made today, :P
loloLo loLO lo lOlo LO lOlolo loloLo loLolo lo Lolo LO loLolo lOlolo lolOlo loLO LO lOlolo loLolo loLolo lololo loLo LO lOlolo loloLo lolO lo lolO LO lOlolo lolO lolO lo lOlo lo lOlolo loloLo LOLo lo loLO LO lOlolo loloLo loloLo lo loloLo LO Lolo LO lOlolo loloLo loloLo lo loloLo LO lolO LO lOlolo loloLo loloLo lo LOLo LO loLolo lOlolo lolOlo LOLo lO lOlolo lolO lolO lo lOlo lo Lolo LO lOlolol

Awesome, 21 Bytes
print "Hello, World!"

"Awesome" is a sample language created in a e-book about language construction which can be found here: http://createyourproglang.com
No, I didn't write this book but it's still worth a look.

Is there an interpreter for it?

I'm not sure if there is a free one, sorry. But, if you buy the book you have a money-back garanty if you don't like it.

FEU, 15 bytes
As sed, need empty input.
a/Hello, World!

Try it online!
Append Hello, World! to the input and the inout is implicitely printed.
Alternative (boring) version, taking no input:
__DATA__
Hello, World!

Try it online!

JSON, 16 bytes
"Hello, World!"

Apparently golfing doesn't need to be Turing-complete. Someone mentioned a meta-post but I took their word for it. And hey, this is the closest to STDOUT there is in JSON.

StackFuck, 18 bytes
"!dlroW ,olleH"{o}

The first cell is not used for the stack (It's the register), and is 0 at the start of the program, so no need to push a 0 at the start

Mathematica 21 Bytes
When run in the kernel console, output will be sent to the kernel console.  Same for the notebook interface.  Since the kernel can be launched from any command line, this will work.
Print@"Hello, World!"

You can also have Mathematica pass the command as a string to the OS like so:
Run["Echo Hello, World!"]

which will open up a command window for a very short amount of time but if you don't blink, you'll see the message.

the one thing mathematica doesn't have a builtin for!

Z, 172 bytes
zz z zzz Z  Z
zz z z zZZ z  Z
zz z z zZZ zzZ  Z  Z
zz z z z z  Z
zz z zz Z  Z
zz z zzZ zzz  Z
zz z z z z  Z
zz z z z zZ  Z
zz z z zZZ zzZ  Z
zz z z zZZ zZZ  Z
zz z zz zz  Z

Yeah... unless you have an interpreter from before the challenge that works with 43 bytes, it doesn't count as 43.

@DestructibleWatermelon Ok, I edited that out.

Zetaplex, 23 bytes
"Hello, World!"SrOsDrFe

Documentation for this language is here, basically this is a stack-based language where every command is 2 characters.

Gammaplex, 22 bytes
X"Hello World!"XXSXrRE

The links for the specs for this lang are dead, you can download the source code (C++) here.

Don't use XS. Just reverse it yourself.

Kitanai, 20 bytes
print"Hello, World!"

Pretty easy to understand :)

Somme, 38 bytes
8s+vi:7+::J:^B4*25p9s6+v:J:6-:8-25pim,

Somme is kind of a complicated language. Some of the finer details are irrelevant, so I'll give you what you need to know.

Somme is stack-based.
The numbers 0-9 push that number, along with A-F pushing 10-15.
The above are treated as 0-arity functions.
When a 0-arity function is invoked, the default pop for the stack is set to the result. So, 8s+ first pushes 8, squares 8, then adds 8 to it. This is 72, orH.
m, prints the stack as characters.

I'll add some more explanation later.

C (works with gcc/linux/x86_64), 129 bytes
Not my original idea, just changed a couple of bytes and golfed a little:
const main[]={-443987883,440,113408,-1922629632,4149,965120,84869120,15544,266023168,1818576901,539783020,1819438935,-1878384284};

Original: http://jroweboy.github.io/c/asm/2015/01/26/when-is-main-not-a-function.html
(prints "Hello World!" without the comma)

Seg fault on my system.

Works on Ubuntiu 16.04.04 using gcc 5.4.0

8th, 16 17 bytes
"Hello, World!" .

Push the string on TOS. Then print the item on stack with .

With version 17.01 of 8th a bug has been fixed. Therefore a space before . is strictly required.

QBIC, 3 bytes
?_H

QBIC has a built-in specifically for this purpose, it was kind of a test to see how this sort of function-calls would look in QBIC source and how the QBasic interpreter would need to handle this. For those who frown upon built-ins:
?@Hello, World!

15 bytes, still not bad. QBIC needs string literals to be closed by a ` (backtick), and auto-closes literals at End-Of-File.

Minkolang v.0.9, 18 bytes
"Hello, World!"$O.

Try it online! The v.0.1 answer seems to no longer, so it makes sense to post an answer in the most recent version.
"Hello, World!"$O.
"Hello, World!"     Push these chars to the stack
               $O   output all these characters
                 .  terminate the program

C++, 54 bytes
#include<iostream>
main(){std::cout<<"Hello, World!";}

Try Me Online!

#include<cstdlib> main(){puts("Hello, World!");} is shorter and still C++ (newline after include, not space)

You can save a byte by removing the space between #include and <iostream>.  i.e. #include<iostream> instead of #include <iostream>

There are so many better ways to do this.

SQLite, 22 bytes
select"Hello, World!";

Try it online!

if you are still there there you don't need semicolon 21 bytes

Changeling, 90 bytes
"IpQ:AQ..
""2(-znK]
"" "Tr4r[
"")$dNcA.
"" #!&...
.........
.........
.........
.........

Try it online!
Background
Changeling is a particularly cumbersome encoding of ShapeScript, designed to make it more difficult to program in and forcing certain geometric shape upon the source code. Both were designed for Create a programming language that only appears to be unusable. I got a little nostalgic when TIO surpassed 200 languages, so since ShapeScript was the very first language on TIO, I decided to add Changeling as the 201st.
All Changeling programs have to form a square of printable ASCII characters. Each line of that square independently creates a bit of ShapeScript code, and the concatenation of these code snippets are evaluated as a ShapeScript program.
Each line begins with an accumulator of 0. For each character c of the line (including the trailing linefeed), the code point of c is XORed with the accumulator divided by 2, and the Unicode character that corresponds to the resulting code point is appended to the source code. Then, the difference between the code point of c and the integer 32 is added to the accumulator, and the next character of the line (if any) is processed.
The resulting program must contain only valid ShapeScript statements or it will not run at all. Exceptions are caught and error messages are replaced with cryptic complaints.
How it works (WIP)
The standard Hello World program in ShapeScript is simply
"Hello, World!"

However, no Changeling program can encode this exact program.
Since the accumulator is initially 0 on each line, modeling the characters at the beginning of each line into something useful is comparatively easy. The remainder of the line can be enclosed in a string (which is later popped) to avoid syntax errors in the resulting ShapeScript code.
"Hell""
"#0#"o,""
"#" Wor""
"#+"ld""
"#"!""

can be generated by
"IpQ:AQ
""2(-znK]
"" "Tr4r[
"")$dNcA
"" #!&

which, by itself, is not a valid Changeling program yet, as its source code is not a square. That's easily fixed by adding characters though, but some care has to be taken not to end the strings started by each trailing " in the ShapeScript program.

JSFuck, 22948 bytes
[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([][[]]+[])[!+[]+!+[]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+[+!+[]])+[])+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()

Welcome to PPCG! All answers on [tag:code-golf] questions such as this one must include their length in their header; I've edited this in for you.

D, 55 53 52 bytes
import std.stdio;void main(){"Hello, World!".write;}

You can save 2 bytes, by removing \n

Capitalization is important. (i.e. change world to World). And won't "Hello, World!".write work?

Crayon, 16 bytes
"Hello, World!"q

Try it online!
Crayon is a stack-based golfing language designed to be good at ASCII-art challenges. Instead of the traditional one-line-at-a-time output format, Crayon writes to a 2D "canvas" of characters, which is sent to STDOUT at the end of the program. The q command writes the top item directly onto the canvas.

Graphic 154 bytes
x=72 printa(x) y=101 printa(y) y+7 y+3 x-28 x-12 x+55 + y-6 y-8 x-54 +
1
2 0 0 13 7 8 9 0
3
4 9 5 6 0 0 0 5 10 11 12
9
9
9
9
9
1 3 3 3 1 1 1 3 3 3 3
9
9
9

There is a trailing newline
This language is based off of a directed graph. The first line is the list of nodes, each consisting of a single command. The following n lines are the links between nodes on the graph.
Explanation
The first line initializes the nodes as
0: x=72
1: printa(x)
2: y=101
3: printa(y)
4: y+7
5: y+3
6: x-28
7: x-12
8: x+55
9: +
10:y-6
11:y-8
12:x-54
13:+
The program starts with a direction value of 0 at node 0.
x=72 go to node 1
Print character represented by x go to node 2
y=101 go to node 3
Print character represented by y go to node 4
Add 7 to y go to node 9
Increment direction by 1 go to node 3
Print character represented by y go to node 9
Increment direction by 1 go to node 3
Print character represented by y go to node 5
Add 3 to y go to node 9
Increment direction by 1 go to node 3
Print character represented by y go to node 6
Subtract 28 from x go to node 9
Increment direction by 1 go to node 1
Print character represented by x go to node 7
Subtract 12 from x go to node 9
Increment direction by 1 go to node 1
Print character represented by x go to node 8
Add 55 to x go to node 9
Increment direction by 1 go to node 1
Print character represented by x go to node 9
Increment direction by 1 go to node 3
Print character represented by y go to node 5
Add 3 to y go to node 9
Increment direction by 1 go to node 3
Print character represented by y go to node 10
Subtract 6 from y go to node 9
Increment direction by 1 go to node 3
Print character represented by y go to node 11
Subtract 8 from y go to node 9
Increment direction by 1 go to node 3
Print character represented by y go to node 12
Subtract 54 from x go to node 9
Increment direction by 1 go to node 1
Print character represented by x go to node 13
End program

√ å ı ¥ ® Ï Ø ¿ , 2 bytes
HW

H  › Push the string "Hello, World!" to the stack
 W › Output the whole stack as Unicode interpretations

Yes it's that basic...

ASP / VBSCRIPT, 13 bytes
Another boring answer!
Hello, World!

~~~, 2200 bytes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬¬_~~~~~~~~~~¬~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬~~~~~~~~~~~~~~~~~~~~~~~~¬~~~¬-¬_~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬

Yet another brainfuck-esque language. This uses UTF-32 encoding
~ adds one to the value
¬ outputs the value mod 127
- move forward along the tape
_ move back along the tape

@ovs "This uses UTF-32 encoding"

This is not a programming language.

shortC, 26 21 19 16 bytes
AR"Hello, World!

Just to showcase the language.

;#
Interpreter provided by @ETHProductions
Read this for a full list of commands.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Sorry, not a language :(

@Challenger5 kolmogorov-complexity challenge. Doesn't have to be

Oh yeah, that's true. Never mind.

Packed Pyth, 13 bytes
Hexdump:
0000000: 4523 2ecd 9bd6 20af bf96 cc88 40         E#.... .....@

Packed Pyth is Pyth with a 7-bit ASCII encoding.
This Pyth program:
"Hello, World

Gets packed into this Packed Pyth program:
E#.͛� ���̈@

To create the file:
$ echo -n '"Hello, World!' > hello.pyth
$ py ../pyth/packed-pyth.py -p hello.pyth hello.ppyth

To run it:
$ py ../pyth/packed-pyth.py hello.ppyth
Hello, World!

Probably the best and most ultimate ever golfing language using only printable ASCII and newlines, now packed!

2Col, 2 bytes
HW

Hooray, another boring answer using a Hello world builtin.

Does this print Hello, World! exactly or some variant of it?

@BetaDecay prints it exactly, followed by a trailing newline

Oh nice. A few answers have had built ins which don't print it correctly

The general convention when it comes to hello world programs is Hello, World! so I made HW do exactly that. Of course I'm screwed if somebody asks me to print Hello World! or Hello World

Can we get a link to more information about 2Col? [Edit: Nevermind I found the GitHub repo. https://github.com/gunnerwolf/2col]

@3D1T0R the title of the answer is also a link to the github. It's a dead language because it comes from the period where I was trying out new language ideas for the heck of it, most of which were quickly dropped.

@3D1T0R oh I didn't see that you made the edit, my bad :P

@Mayube: No problem.

Noether, 16 bytes
"Hello, World!"P

Try it here!
Noether is basically a stack-based, Reverse Polish Notation version of Fourier. Plans for this language include overloaded functions and string functions.
Noether is named after the pioneering mathematician Emmy Noether.
Explanation:
"Hello, World!" - Push the string "Hello, World!" to the stack
P               - Print the item on the top of the stack

Python 1, 20 bytes
print"Hello, World!"

Try it online!

This is a duplicate of a previous answer... I'll find it

@BetaDecay https://codegolf.stackexchange.com/a/55432 and https://codegolf.stackexchange.com/a/103839

To any delete-voters, this is a valid answer in a language that hasn't yet been used. It is no longer a duplicate to the two pointed out by ETHproductions. It may not be particularly interesting, but that is no reason to delete this answer.

Decimal, 48 bytes
13072069076076079044032087079082076068033010D301

This uses only two commands:

13 - push a STRING
301 - print from stack to output

On the date of posting, Decimal has another Hello World that's a bit more boring:
Hello,13032301World!

According to the README:

Decimal, also called 09D, is an esoteric stack-based programming language that uses the characters 0 through 9 and D. Any other characters in the source code are simply printed.

But spaces and newlines are ignored, because those often fallthrough from comments and commands, adding the necessity for the 13032301. (I need to update the README.)

Neim, 16 bytes
(Hello, World!)B

Try here
Made possible thanks to (partial) BigInteger support.

Ly, 19 18 bytes
"!dlroW ,olleH"[o]

First submission in my new language!

I suspect &o was added later?  Anyway "Hello, World!"&o is one byte shorter.

Positron, 21 bytes
print@"Hello, World!"

Try it online!
Just to get this out there :)

Emmental, 68 bytes
#0#10#33#100#108#114#111#119#32#44#111#108#108#101#72...............

From the esolangs.org page.

57 bytes

Caker, 294 bytes
ωΩθΩθθΩθΩθθθΘΩθθΩθθΩθΩθΩθΘθθΩθΩθθΩθθΘΩθθΩθΩθθΩθθΘΩθθΩθΩθθθθΘθΩθΩθθΩθθΘΩθΩθθθθθΘΩθΩθΩθΩθΩθθθΘθθΩθΩθθθθΘθθθΩθθΩθΩθΘΩθθΩθΩθθΩθθΘΩθθΩθθΩθΩθθΘΩθΩθθθθΩθΘ

Looks like alot of zeros...

SE, 66 61 bytes
array h is [H e l l o , _space W o r l d !] end
do>with h end

T h i s _space e s o l a n g _space i s _space b a d _space a t _space o u t p u t ! (This esolang is bad at output!)
SE stands for self-explanitory, not Stack Exchange :(.

ABCD, 390 bytes
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAADDAAADBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBDBBBBBBBBBBBBDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAADAAADBBBBBBDBBBBBBBBDBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBDBBBBBBBBBBBBBBBBBBBBBBBD

AAHH! This is a weird esolang.

cQuents, 15 bytes
Hello, World!?0

Try it online!
Explanation
Hello, World!    Literal "Hello, World!"
             ?   Mode ? (query)
              0  Necessary for interpreter
                 Because there is no input for query mode, only print literals

@, 2 bytes
The language is made of a tree of function calls. Each character (with some exceptions) represents a function that may take as many or few arguments as it likes. Arguments are then read from directly after it in the code.
ħ

The ħ builtin returns the string "Hello, World!"

Dreaderef, 31 bytes
This file contains unprintables. Here is a reversible hexdump created with xxd:
00000000: 2206 4806 6506 6c06 6c06 6f06 2c06 2006  ".H.e.l.l.o.,. .
00000010: 5706 6f06 7206 6c06 6406 2106 5c6e 22    W.o.r.l.d.!.\n"

Try it online!
How does it work?
The reason this file is so unreadable is because it makes use of string literals to golf the code. The preprocessor expands string literals into their respective character values. The actual numbers this represents are:
6 72 6 101 6 108 6 108 6 111 6 44 6 32 6 87 6 111 6 114 6 108 6 100 6 33 6 10

6 is the command associated with chro (char output). So this code looks like this:
chro 72
chro 101
chro 108
chro 108
chro 111
chro 44
chro 32
chro 87
chro 111
chro 114
chro 108
chro 100
chro 33
chro 10

PATH, 113 bytes
/++}+++++++}+++++}<$+++++++<
\+}++}++++++{{{{{-^}++.}+++.+++++++..+++.}++.}++++.}+++.{{{.+++.------.--------.}}+.

Try it online!

JoshScript, 596 bytes
JOSHJoshJoshJoshJoshJoshJoshJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshJoshJOSHJOshJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOshJOshJOSHJOSHJOSHJOshjosHjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshJOshjosHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshJoshJoshjoshJOshJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOshJOSHJOSHJOSHJOshjoshjoshjoshjoshjoshjoshJOshjoshjoshjoshjoshjoshjoshjoshjoshJOshjosHjosHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOsh

JoshScript is an esoteric language that is made up entirely of joshes.
JoshScript is pretty easy to learn, below is the usage of JoshScript v1.01
JOSH increases the value by 1
josh decreases the value by 1
Josh multiplies the value by 2
josH divides the value by 2 and rounds down to the nearest integer
JOsh outputs the current value
joSH takes input and sets the value to the ascii repr. of the char
im not josh-obsessed i promise

BrainFlump, 362 bytes
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++:..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.;.--------.-------------------------------------------------------------------.

Try it online!
Should be shorter once we fix loops, but that's it for now.

Bitwise, 149 bytes
MOV 1 &1 &1
OUT &72 1
OUT &101 1
OUT &108 1
OUT &108 1
OUT &111 1
OUT &44 1
OUT &32 1
OUT &87 1
OUT &111 1
OUT &114 1
OUT &108 1
OUT &100 1
OUT &33 1

Pretty simple - just prints integer literals (&x) as ASCII characters. MOV 1 &1 &1 sets the 1st register to 1, so that each line can save 1 byte (using 1 instead of &1). The second variable to OUT is not optional. If the second variable (register/frame register/literal) is true, the character will be printed, otherwise it will not.
Try it online!

Рапира (Rapira), 57 26 22 bytes
OUTPUT:"Hello, World!"

Try it online!
Or, more appropriately, (33 bytes):
ВЫВОД:"Привет Мир!"

As far as I can tell, this defines a procedure without calling it, which violates the full program requirement. A simple output:"Hello, World!" works though.

@Dennis Okay. That saves 30 bytes, too!

The English version without the space is 4 bytes shorter...

@Dennis If you're going to use English, why bother using Рапира?

Nhohnhehr, 181 bytes
+-----------+
|$010010000\|
|1100101011\|
|0110001101\|
|1000110111\|
|1001011000\|
|0100000010\|
|1011101101\|
|1110111001\|
|0011011000\|
|1100100001\|
|00001  @  \|
+-----------+

Try it online!

Archway2, 182 bytes
                   \
 /
  >++>+++>+++>+<<<<-/>+>+>->+<<<<<-\>>.>---.+++++++..+++.>>++++.------------.<-.<.+++.------.--------.>>+.
  \    \
\++++>
++++++++/                         /

Try it online!
This program was derived from the Hello, World! program that I wrote for TIO. I realized that the code not inside the sub-loops can be aligned with the code inside the sub-loops removing some redundant direction changing. Unrolling the loop consisting of only a < to <<<< saves many bytes by not requiring the spaces to support the positioning of the reflectors. Flipping the main loop to go around the bottom of the program instead of the top allows the first few instructions of the main loop to be put on its own line while still being reachable from the start of the program. This lets us move the sub-loop closer to the edge of the program saving bytes.

Symbolic Python, 200 bytes
Managed to cut down 16 bytes from my original example on the wiki. Note that the unprintable on line two is \xc2\x8d.
This can definitely be shorter, but it took me long enough. I'll come back to it another time.
__=-~(_==_)
__=`_`[~__]+`_>_`[__::__]+`''`[-__::~__**__]
_=_==_
___='%'+__[-_]
__,_=___+__[-~_]+__[_]*-~_+__[_>_]+', '+___+__[_>_]+`_`[_]+__[-~_-_]+__[~_]+'!',-~-~_
___=_*_<<_
_=__%(___,___+_*-~-~_)

Try it online!

Cool, but JSF*ck is better.

Brain-Flak, 448 bytes
((()()()()()()()()()()())({}){})
((()()()()()()()()()())({})({})({})({})({})({})({})({}){})
(([][][][][][])({})({})({})({})({})({})({}){})
(([][][][][][]())({})({})({})({}){})
(([][][]()())({})({})({})({})({})({}){}[()])
(([][][][])({})({})({})({}){}[()])
(([]()())({})({}){})
(([]()()()())({})({}){})
(([]()()())({})({})({})({})({})({})({})({}){}())
((([]()()())({})({})({})({})({})({})({}){}))
(([][][()()])({})({})({}){}())
([]()())(({})({})({})({}){}()())

Try it online!
Newlines added for clarity

Excel VBA, 15 Bytes
Anonymous VBE immediate window function that takes no input and outputs Hello, World! to the VBE immediate window.
?"Hello, World!

Verbosity, 382 bytes
Include<Integer>
Include<MetaFunctions>
Include<Output>
Include<String>
Integer:DefineVariable<o;1>
Output:DefineVariable

String:DefineVariable<s;"Hello, World!">
String:RedefineVariable<s;String:RemoveCharactersFromStart<s;o>>
String:RedefineVariable<s;String:TakeFirstCharacters<s;o>>
Output:DisplayAsText

DefineMain<> [
MetaFunctions:ExecuteScript<MetaFunctions@FILE>
]

Try it online!
Ungolfed
Include<Integer>
Include<MetaFunctions>
Include<Output>
Include<String>

Integer:DefineVariable<one; 1>
Output:DefineVariable<STDOUT; 0>
String:DefineVariable<string; "Hello, World!">

String:RedefineVariable<string; String:RemoveCharactersFromStart<string; one>>
String:RedefineVariable<string; String:TakeFirstCharacters<string; one>>

Output:DisplayAsText<STDOUT; string>

DefineMain<> [
	MetaFunctions:ExecuteScript<MetaFunctions@FILE>
]

Try it online!
I proudly present yet another language: Verbosity. Who needs to be good at code golfs, when you have a language like this?

I'm somewhat impressed at how it manages to error out on all my attempts to "obviously" shorten it.

Whispers, 29 bytes
> "Hello, World!"
>> Output 1

Try it online!
An even newer language than Verbosity.
How it works
> "Hello, World!" - Line 1
>                 - Yield a constant value, which is...
  "Hello, World!" -   The string "Hello, World!"

>> Output 1       - Line 2
>>                - Replace numbers with line references
   Output         - Output the value...
          1       - ...on line 1

Assembunny, 100 bytes
out 72
out 101
out 108
out 108
out 111
out 44
out 32
out 119
out 111
out 114
out 108
out 100
out 33

I think I could have miscounted.
Explanation
This code uses the extra signal generator instruction out x from day 25 for output.
This is the output:
  Dec  72 101 108 108 111  44  32 119 111 114 108 100  33
  Hex  48  65  6C  6C  6F  2C  20  77  6F  72  6C  64  21
ASCII   H   e   l   l   o   ,       w   o   r   l   d   !

face, 41 bytes
(Hello, World!
)\$*m%*7%+%%%,c'$,ioow%$%o

Explanation:
(...)   comment, skipped over by interpreter but used to embed string in source
\$*     assign $ to a pointer to the source code and * to a pointer to the IP
m%*     malloc space for %, a variable which will be used to store the length
7%+%%%  set % to 14 in a roundabout way (% = 7, % += %), the length of the string
,c'$,i  step into char mode to increment $, setting the start of the string
oo      set o to stdout
w%$%o   fwrite(str, 14, stdout), throwing the return value into %

Try it online!

Pyt, 40 39 bytes
89*2ᴇ⁺Đ7+ĐĐ3+5⬡⁻2⁵9²6+Đ4!+Đ3+Đ6-2ᴇĐ₃áƇǰ

Explanation:
89*                                                  Pushes 72 ('H')
   2ᴇ⁺                                               Pushes 101 ('e')
      Đ7+                                            Duplicates 101, then adds 7 ('l')
         Đ                                           Duplicates 108 ('l')
           Đ3+                                       Duplicates 108, then adds 3 ('o')
              5⬡⁻                                   Pushes 44 (',')
                  2⁵                                 Pushes 32 (' ')
                    9²6+                             Pushes 87 ('W')
                        Đ4!+                         Duplicates 87, then adds 24 ('o')
                            Đ3+                      Duplicates 111, then adds 3 ('r')
                               Đ6-                   Duplicates 114, then subtracts 6 ('l')
                                  2ᴇ                 Pushes 100 ('d')
                                    Đ₃               Duplicates 100, then divides by 3 (Python 2-style integer division)
                                      á              Replaces the stack with an array containing the stack's contents
                                       Ƈ             Cast to unicode characters
                                        ǰ            Join strings
                                                     Implicit print

Try it online!

Ace, 1 byte
H

Try it online!
This is a golfing language I am currently in the process of making, so I thought I'd post it here. It's based on Aceto. I wasn't quite satisfied with what Aceto had to offer but I really liked using it so I decided I'd make my own language and include more builtins and NOT RUN THE IP ON A HILBERT CURVE. It currently has ~30 commands and I am improving it every day. I plan to get it officially on TIO by August 2018

It's now 2020. Have you added it to TIO yet?

Clean, 30 bytes
module m
Start="Hello, World!"

Try it online!
TIO link is 3 bytes longer to match TIOs file name: main.icl

Commentator, 197 bytes
         {-        -}!/*{-{-           {-         -}!  /*       /*/*   /*-}-}#    {-   -}!/*{- e#-}///*{-e#-}//{-#  -}!{-# e#-}///*{-{-/*   /*{-e#-}//   /*-}-}             /*#   {-            -}!/*

Try it online!
I'm genuinely surprised it took me this long to make a somewhat golfed Hello, World! program in Commentator.

Yabasic, 16 bytes
May there always be BASIC in this world!
?"Hello, World!"

Try it online!

Good old BASIC and it's ? abbreviation for PRINT!
Also it's seemingly unique ability to recognize = as both assignment and test for equality. The things I got called on Reddit for suggesting modern languages could learn from this...

@CalebFuller yes, ? is single character version of print that dates back to the days where computers could only display 40 columns of text :P

Cool. Another interesting fact is that most BASIC functions (and many keywords) are 3 letters (INT, SQR, RND, REM, DIM) because the original development mainframe used 6-bit characters, and a 20 bit word, so 3 letters would fit in a single word (plus 2 spare bits for flags) An early example of Code Golf in the language design itself.

MY-BASIC, 20 bytes
Print"Hello, World!"

Try it online!

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

Short, Sweet, and simple.
I do not believe it's possible to make this program any smaller. If someone does, congratulations.

This has already been done, and with less bytes (actually, it's the exact same submission, but you miscounted here).

Nice to know. I'm new enough that I don't know if a search function exists for searching the answers (If one does, i can't find it)

Some challenges, including this one, have a Javascript leaderboard snippet included in the question. (When there isn't, I don't know how to search well either.)

@ØrjanJohansen Searching for "Rust" answers on this question seems to work.

17, 71
777{44 $ 5g $ 66 : : $ $ 69 : $ 1f $ 52 $ $ 6c $ $ 5f $ 1g $ a $ 0 @}

Explantation:
Pushes ascii values for Hello World!(in base 17). Then store 17 at 0, to make it exit by relying on the fact that if it tries to pop at number and the stack is empty it return 17 to save two characters.

17 in 71... nice. waiting on that 54 byte golf though :)

NEUPL, 14 bytes
"!dlrow ,olleH

Try it online
Explanation:
"!dlrow ,olleH
"               Begin pushing characters to the stack.
 !              Push the character "!" to the stack.
  d             Push the character "d" to the stack.
   l            Push the character "l" to the stack.
    r           Push the character "r" to the stack.
     o          Push the character "o" to the stack.
      w         Push the character "w" to the stack.
                Push the character " " to the stack.
        ,       Push the character "," to the stack.
         o      Push the character "o" to the stack.
          l     Push the character "l" to the stack.
           l    Push the character "l" to the stack.
            e   Push the character "e" to the stack.
             H  Push the character "H" to the stack.
                Implicitly stop pushing characters to the stack.
                Implicitly pop and print each character in the stack.

R16K1S60 Assembly, 56 Bytes
a:
mov bx, .b
.l:
mov ax, [bx]
send 4, ax
add bx, 1
cmp bx, .c
jne .l
.h:
hlt
jmp .h

.b: dw "Hello, World!"
.c: dw 14

Writes output to screen peripheral the R16K1S60 in ASCII. Runs on The Powder Toy save 2012356. (See link in header for info)
Note: How exactly should this be scored? I'm assuming just score the size of the ASM.

The link is a 404. I'd score the length of the resulting machine code, if that's a thing.

I'll try and get the length. I'll also fix the link.

Code is 56 bytes compiled. I'll fix the byte count. However, i'm afraid a hexdump is beyond my reach at the moment, i don't know how the R16K1S60 encodes instructions on FILT, only that it uses 16 of the 48 available bits for it's word.

Ook!, 1426 bytes
Ook! is a joke esoteric programming language created by David Morgan-Mar. It is identical to Brainfuck, except that the instructions are changed into Orangutan words. It represents the first, although unfortunately not the last, in a long line of trivial Brainfuck command substitutions. As such, it is a member of the TrivialBrainfuckSubstitution family of programming languages.
Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook.
Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook?
Ook! Ook! Ook? Ook! Ook? Ook. Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook.
Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook.
Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook.
Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook.
Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook!
Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook. Ook! Ook.

Apparently there is already a shorter Ook! answer for this challenge, based on the shortest Brainfuck answer. :) Welcome to PPCG, though!

Crayon, 16 Bytes
"Hello, World!"q

Try it online!

Welcome to PPCG!

Felix, 21 bytes
print"Hello, World!";

Try it online!
Somebody linked to this language on PPCG and I thought it was interesting. In the interest of getting to know the language, I thought I'd write some programs in it.
The Felix docs all use print$ x instead of print x because print is a procedure and not a keyword, so use of the Haskell-style low-precedence application operator $ allows a slightly more natural syntax (compare print (1 + foo(5)); with print$ 1 + foo(5);. I'm not sure I agree completely with this, but it's just a convention and as I'm on PPCG I can break it without feeling guilty.
print is Felix's function to output something, with no trailing newline.

Momema, 63 bytes
0-9*072*0101*0108*0108*0111*044*032*087*0111*0114*0108*0100*033

Try it online!
This is a golfed version of the Hello World program given by TIO. The only difference is that we store the value -9 (the cell which is memory-mapped for character-based I/O) in cell 0, and then use *0 (the value of cell 0) instead of -9 everywhere. This wouldn't save bytes except that Momema will parse a leading 0 on a string literal as a separate number, so you can write e.g. *0108 instead of -9 108. This saves a byte for every write.
As hinted above, the program consists of a series of writes of various codepoints to -9 (the address which is memory-mapped to perform character-based I/O). In ungolfed form, it looks like:
0   -9
*0  72
*0  101
*0  108
*0  108
*0  111
*0  44
*0  32
*0  87
*0  111
*0  114
*0  108
*0  100
*0  33

Brat, 17 bytes
p "Hello, World!"

Try it online!

Dreaderef, 42 bytes
"??	?\r?0"-1"Hello, World!\n"

Try it online! This file contains unprintables. Hexdump:
00000000: 2201 1004 013f 0704 3f09 3f07 5c72 063f  "....?..?.?.\r.?
00000010: 0201 1510 0130 222d 3122 4865 6c6c 6f2c  .....0"-1"Hello,
00000020: 2057 6f72 6c64 215c 6e22                  World!\n"

There already is a Dreaderef submission, but this uses a different approach (looping through memory rather than printing out each character directly).
Ungolfed:
CODE.
; Dereference the string pointer
0.  deref 16 4
; End the program if the value pointed to is zero
3.  deref ? 7
6.  bool ? 9
9.  ? 7 13 ; Black magic
12. chro ?
; Increment the string pointer
14. add 1 21 16
; Go back to the beginning
18. deref 100 -1

DATA.
21. "Hello, World!\n"

MachineCode on x86_64, 125 bytes
4889f8c60748c6470165c647036cc647026cc647046fc647052cc6470620c6470757c647086fc6470972c6470a6cc6470b64c6470c21c6470d00c3
sbrk()

Requires string output via the s flag. Try it online!
This language works like so:

The first line is machine code. This is translated to a C function.
The second line is C code. It specifies the arguments to the function created in line 1.
A command-line argument specifies how the function's return value is used.

So, the machine code is equivalent to:
char *a(char *s) {
    s[0]='H'; s[1]='e'; s[2]=s[3]='l'; s[4]='o'; s[5]=','; s[6]=' '; s[7]='W'; s[8]='o'; s[9]='r'; s[10]='l'; s[11]='d'; s[12]='!'; s[13]=0;
    return s;
}

I generated the machine code via my C lambda script.

DipDup, 15 bytes
[Hello, World!]

Try it online!

Reflections, 41 bytes
_Hello, World!;#_#_#_#_#_#_#_#_#_#_#_#_#_

Test it!
Explanation:

The _ at (0|0) pushes my source to the stack.
Hello, World! consists of no-ops
; pops the first character.
13 times #_:

# redefines (0|0)
_ at (1|0) prints a character

Dirty, 16 bytes
'Hello, World!'‼

Try it online!

R16K1S60, 42 40 bytes
Program:
C301 000D 0001 5180 2C20 A539 0008 5100 C589 00FF 4701 0003 1000 4865 6C6C 6F2C 2057 6F72 6C64 2100

Source:
[C301 000D] mov sp,hello ;set the stack pointer to the start of the message
[0001     ] dw 1 ;do nothing + skip next instruction
loop:
    [5180] send 0,cx ;output cx (skipped the first time)
    [2C20] pop bx ;read a value into register bx
    [A539 0008] shr bx,cx,8 ;copy bx into cx, shift bx 8 bits to the right
    [5100] send 0,bx ;output bx
    [C589 00FF] @flags and cx,0xFF ;get the lower 8 bits of cx
[4701 0003] jnz loop ;repeat if cx is not 0
[1000] hlt ;end

hello:
    [4865 6C6C 6F2C 2057 6F72 6C64 2100] db "Hello, World!" ;byte data

MachineCode, 68 62 bytes
e80d00000048656c6c6f2c20576f726c6421596a015b6a0d5a6a0458cd80c3

Credit to ceilingcat for finding this (and for the language inspiration). Try it online!

Here's a hacky version that isn't true machine code but works with my language.
MachineCode, 54 bytes
e80d00000H656c6c6f2c20576f726c6421596a1[6adZ6a4Xcd80c3

Abuses the current compiler's parser. Try it online!

Jstx, 2 bytes
₧P

Try it online!

QUARK, 46 bytes
33 100^8+^6+^3−87 32 44 111^3−^^7−72›I

Sets up the numbers in reverse order, with quick number twiddling used for the lowercase characters, as they are quite close together.

Attache, 21 bytes
Print!"Hello, World!"

Try it online!

Lorale 37 (36) bytes
This is a language I am making. It shouldn't count as a loophole, as I am making this legitimately, but a hello world program requires you to pass this to the interpreter as args:
;Main{§vmain(){¶"Hello, world!"}};

Alternatively, the program could be put into the semi-IDE as:
Main{§vmain(){¶"Hello, world!"}};

making it 36, not 37 bytes.
Main{                                 Defines the main class
     §v                               Defines a void
       main(){                                       named main
              ¶"Hello, world!";       Prints "Hello, world!"
                              }};     Closes the main method and class

I think that 36 is allowed.

Beatnik, 111 bytes
k zzzzzzzzc k xx k x k d k k k zzxa k zzzzzzzzf xw k zd z xw xo k k k x xw k zk
k zzzzzzzzzzxx qs z xo xw xj kd

Try it online!
Non-crashing version, 117 bytes
k zzzc xw xw z k xx k x k d k k k zzxa k zzzzzzzzf xw k zd z xw xo k k k x xw k zk
k zzzzzzzzzzxx qs z xo xw xj kd xo

Try it online!

Subskin, 47 bytes

48
6f
2
a
1
4
1
4

a
3
3

43
4f
18

-3
3
b
4e

Try it online!
So Ruby allows negative indices.

IO, 20 Bytes
"Hello, World!"print

Other possibility, 21 22 Bytes
write("Hello, World!")

Welcome to PPCG! You can add a TIO link so everybody can run your program easily.

You can do the same in 19 bytes by removing the space between the string and print.

I wasn't knowing about TIO. Thanks for the link

@ovs that doesn't have a comma >_>

@ASCII I put the comma  and removed the space as suggested so that it's still 20 bytes

BrainfuckSubstitutor, 65 bytes
_--!+++?>>/<<
+[_>-[?+>__-/]<_<_-]>-.>?+.?..![.>]//.!.___./-.??+.

Based off KSab's Brainfuck answer.

tinyBF, 94 bytes
+|=++=>=+=|>>+>=+++++>>|>++>+++|=>=+===>>>+==>>====+++|==>=|>>>>===+++===++++++==>>+===>>>>+==

Try it online!
I noticed there wasn't a tinyBF answer here. This is based on Ksab's record-breaking brainfuck answer.

brainfuck, 137 bytes
++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.>+.+++++++..+++.<<++++++++++++++.------------.>+++++++++++++++.>.+++.------.--------.<<+.

Try it online!

Explained :
++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.                       H
>+.                                                                    e
+++++++..                                                             l l
+++.                                                                   o
<<++++++++++++++.                                                    comma
------------.                                                        space
>+++++++++++++++.                                                      W
>.                                                                     o
+++.                                                                   r
------.                                                                l
--------.                                                              d
<<+.                                                                   !

This can definitely be golfed. (World record is 72 bytes so I already know that)

This is basic hard coded answer, simply gets the Ascii value, resets and keeps going
brainfuck, 210 bytes
-[>+<-------]>-.[-]<-[>++<-----]>-.+++++++..[-]>+[+>+[<]>->]<.[-]--[>+<++++++]>+.[-]>-[-[-<]>>+<]>-.[-]-[>+<---]>++.[-]>+[+>+[<]>->]<.[-]>+[-->++[<]>-]>.[-]>+[++[++>]<<+]>+.[-]-[>++<-----]>--.[-]>-[-[-<]>>+<]>.

Try it online!
Explained :
-[>+<-------]>-.                                               H
[-]
<-[>++<-----]>-.                                               e
+++++++..                                                     l l
[-]
>+[+>+[<]>->]<.                                                o
[-]
--[>+<++++++]>+.                                               ,
[-]
>-[-[-<]>>+<]>-.                                             space
[-]
-[>+<---]>++.                                                  W
[-]
>+[+>+[<]>->]<.                                                o
[-]
>+[-->++[<]>-]>.                                               r
[-]
>+[++[++>]<<+]>+.                                              l
[-]
-[>++<-----]>--.                                               d
[-]
>-[-[-<]>>+<]>.                                                !

HadesLang, 20 19 bytes
-1 byte thanks to Oliver
out:'Hello, World!'

Welcome to PPCG! The output should be Hello, World!, not Hello world!. Also, there's an escaped dot in your link; it is broken for me.

Based on the docs, it looks like you can omit the brackets: out:'Hello, World!'

Uppercase that w, and your answer will look valid :-) Also, welcome to PPCG, we're glad you're here!

@Oliver Thanks! Will do! :)

Thing, 37 bytes
Pushes the characters to the stack one by one (the second "l" is made with duplication, saving 1 byte), then concatenates them.
\!\d\l\r\o\W\ \,\o\ld\e\H++++++++++++

Try it online!

TapeBagel, 511 bytes
%% %++ %++ %++ %++ %++ %++ %++ %++ @* ## %++ %++ %++ %++ %++ @* ## %++
%++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ @* @* ## %++ %++ %++ %++
%++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ @* ## @* %++ %++ %++ %++
%++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ @* ## %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ @* ## %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ %++ %++ %++ @* ##  %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ @* ## %++ %++ %++ %++ @* ##

%# - adds one to the integer index.
%% - resets the integer index to zero.
%& - the integer that the integer index is pointing to is inputted into the program.
#% - sets all of the integers to one.
## - resets all of the integers to zero.
&& - pauses the program.
&@ - clears the screen.
%++ - adds one to the integer that the integer index is pointing to
@[ int ] - outputs the integer as a character (1 = A, 2 = B, ... 26 = Z)
* - integer 0

Sisi, 21 bytes
0print"Hello, World!"

Try it online!

Q#, 43 bytes
function H():String{return"Hello, World!";}

Try it online!
Might as well put it out there. Q# is Microsoft's programming language for quantum computers, not that there's anything quantum happening here.
"Now hold on a moment! This isn't a complete program!"--You, probably.
Well, it's not actually possible to write a complete program in Q#. You always have to call it from a different language. So I'm just submitting a "function", although note that while Q# is a .NET language, the function keyword actually defines a class and not a method, and the submission is equivalent to the following C# code:
public class H : Operation<QVoid, String>, ICallable
{
    public H(IOperationFactory m) : base(m)
    {
    }

    String ICallable.Name => "H";
    String ICallable.FullName => "qsharp.H";
    public override Func<QVoid, String> Body => (__in) =>
    {
        return "Hello, World!";
    }

    ;
    public override void Init()
    {
    }

    public override IApplyData __dataIn(QVoid data) => data;
    public override IApplyData __dataOut(String data) => new QTuple<String>(data);
    public static System.Threading.Tasks.Task<String> Run(IOperationFactory __m__)
    {
        return __m__.Run<H, QVoid, String>(QVoid.Instance);
    }
}

You can use this link to "disassemble" Q#.

*transpile, not disassemble

µ6, 25 bytes
,200,245,300,300,303,112,52,223,303,310,300,244,53

Try it online!
Explanation
Just apply the ASCII code-points to the pairing function , - strings/string-manipulation is not really the strength of µ6 (I guess nothing really is).

ABC, 21 bytes
WRITE "Hello, World!"

Try it online!

ABC-assembler, 80 39 bytes
.start s
s
 print "Hello, World!"
 halt

Try it online!

78?

@ASCII-only even shorter actually.

Haha, I almost got that :P where are the docs for this btw

@ASCII-only there's a paper here but there aren't really any.

LC-3 object file, 36 bytes
.ORIG x3000
LEA R0, TEXT
TRAP x22
HALT
TEXT .STRINGZ "Hello, World!"
.END

This compiles to an object file:
ibug@ubuntu:~ $ hexdump -Cv hello.obj
00000000  30 00 e0 02 f0 22 f0 25  00 48 00 65 00 6c 00 6c  |0....".%.H.e.l.l|
00000010  00 6f 00 2c 00 20 00 57  00 6f 00 72 00 6c 00 64  |.o.,. .W.o.r.l.d|
00000020  00 21 00 00                                       |.!..|
00000024
ibug@ubuntu:~ $ stat -c "%s" hello.obj
36
ibug@ubuntu:~ $

JVM bytecode (OpenJDK asmtools JASM), 235 bytes
public class h {public static Method main:"([Ljava/lang/String;)V" stack 2 locals 1 {getstatic java/lang/System.out:"Ljava/io/PrintStream;";ldc "Hello, World!";invokevirtual java/io/PrintStream.println:"(Ljava/lang/String;)V";return;}}

Ungolfed
public class h {
    public static Method main:"([Ljava/lang/String;)V" stack 2 locals 1 {
        getstatic java/lang/System.out:"Ljava/io/PrintStream;";
        ldc "Hello, World!";
        invokevirtual java/io/PrintStream.println:"(Ljava/lang/String;)V";
        return;
    }
}

Pretty much the same thing as Jasmin, just with a different syntax.

I just found out about a static method sun.misc.MessageUtils.out from this answer. It does the same thing  as System.out.println but should work out to be substantially shorter because it's a static call rather than virtual call.

JS (Windows Script Host), 25 bytes
WSH.Echo("Hello, World!")

I don't know if someone did already post Windows Script Host JS.

Different languages should usually go in separate answers. Especially in challenges like this one which has an automatic leaderboard - only your first language shows up there.

VBS (Windows Script Host), 26 bytes
WScript.Echo "Hello, World!"

VTL-2, 21 bytes
1 ?="Hello, World!"

? is the I/O system variable in VTL-2. Byte count may seem off, but line numbers are always two bytes, and the CR at the end of the line is mandatory and counted. Space between line numbers and commands is also mandatory.

Scala, 63 bytes
object Main{def main(a:Array[String])=print("Hello, World!")}

Try it online!

an existing answer is shorter

That shorter answer doesn't work in tio. One of the requirements in this particular assignment was that each submission must be a full program.

Also, that answer has extra \n in the string.

The shorter one, sure. But not the longer one, which is still shorter than yours. Plus, yours is the one with extra newline, and incorrect capitalization for the W :|

You are right, that answer is better and provides full version that works in tio.

Keg, 15 bytes
Hello\, world\!

Keg pushes all of the unrecognized commands onto the stack (with , and ! escaped). After the program terminates, it prints the content of the stack.

Now I feel bad.

33, 16 bytes
"Hello, World!"p

But that's boring, isn't it?
Let's try with functions, instead.
56 bytes
{"Hello"p}'Hello'{", "p}', '{"World"p}'World'{"!"pi}qqqq

Here's something to be explained.
The string registers are initialised to "" when the interpreter starts. When the
interpreter encounters a {, it copies all the code until the matching } and
stores it as a function, labelled as what the destination string register was at
the time (The destination string is set by single quotes).
Changes to the registers persist when changing stack frames (is that the right term?), so the explanation looks like this:
{                                                         (Creates function "")
  "Hello"                                                 (Stores "Hello" in the source string register)
         p                                                (Prints what is in the source string register)
          }'Hello'{                                       (Creates function "Hello")
                   ", "p                                  (Prints ", " after storing it in the source string register)
                        }', '{                            (Creates function ", ")
                              "World"p                    (Prints "World" after storing it in the source string register)
                                      }'World'{           (Creates function "World")
                                               "!"p       (Prints "!")
                                                   i      (Prints a newline)
                                                    }q    (Calls function "")
                                                      q   (Calls function "Hello")
                                                       q  (Calls function ", ")
                                                        q (Calls function "World")

This is a language I created. The source is in the link. I haven't made a Windows release of the interpreter yet, because I cannot figure out how to cross-compile. If you're on Windows, you'll have to compile it yourself.

anyfix, 14 bytes
“Hello, World!”

Simply the string, pushed onto the stack. Really boring.
(By the way, just use postfix for all operators in anyfix; this leads to the least confusion compared to infix modes and prefix modes, and anyfix is the easiest to understand in the postfix mode.)
TIO

Simula (cim), 24 bytes
OutText("Hello, World!")

Try it online!
Over 750 answers and we can still find languages not yet submitted. Wowsers.

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

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

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

Wren, 29 bytes
System.print("Hello, World!")

Try it online!
Explanation
System.print(               ) // Output the following string:
             "Hello, World!"  // "Hello, World!"

Intcode, 83 72 70 bytes
204,8,109,1,1205,8,0,99,72,101,108,108,111,44,32,87,111,114,108,100,33

Try it online!
Old 83 byte version:
1106,0,17,72,101,108,108,111,44,32,87,111,114,108,100,33,0,204,3,109,1,1205,3,17,99

Consider a TIO link using your own interpreter for now? like so

@ValueInk Done.

tq, 15 bytes
"Hello, World!"

Pretty much just defines a list with the only item as the string "Hello, World!".

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>

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

Deadfish~, 1 byte
w

Try it online!

evil, 70 bytes
aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Try it online!

Just in case you missed it, there is a shorter evil solution, posted by my pronoun is monicareinstate 2 months ago.

@manatwork oh whoops. does that mean I should take this down?

No, there is nothing against such solutions. Mentioned it more as fun fact.

Actually I also missed the relevant one: grc posted this exact evil solution 4 years 6 months ago. ☹

Scala 3, 34 bytes
@main
def m=print("Hello, World!")

Thought Dotty deserved its own answer.
Try it in Scastie

kavod, 47 bytes
72#101#108#108#111#44#32#87#111#114#108#100#33#

Try it online!

Rust, 36 bytes
Extremely basic, and no explanation needed, but here:
fn main(){println!("Hello, World!")}

If, for some reason, anyone would like to try it, you can here

Actually your code is 35 bytes long. But because the output must be exactly as required (including uppercase “W” and trailing “!”), the correct code's length will be 36.

Thanks! I changed the byte number, and corrected the hello world

Golunar, 66 bytes
142209095870573693396245504627320468349603549841832242891887476756

Python 3 + lkjqwhe, 8 bytes
import a

Well, I beat It's-a-fake-one-Daniel. ¯\_(ツ)_/¯

You can get shorter names - qag hasn't been taken yet

@Ausername I guess so, but it doesn't save bytes, and I'm too lazy to do so (not like it matters)

Grok, 23 bytes
`jiHello, World!
}lYW
q

Non-terminating version, 18 bytes
iHello, World!`lwh

Deadfish~, 1 byte
w

Try it online!
Kind of cheating really... but then I think there are some zero byte answers!

This was already posted here last year, unfortunately :( we do technically allow duplicate answers, so it is up to you if you keep or remove it

():;+-#?!, 26 bytes
:H:e:l:l:o:,: :w:o:r:l:d:!

Try it online! (Node.js interpreter)

Interesting! Is this your language?

@ophact no, I found it on the esolangs.org, you can click the link to know more

EmojiCoder, 532 bytes

Try it online!
EmojiCoder is a funny language!
 represents binary 0 and  binary 1. We construct the binary numbers of ASCII codepoints in Hello, World!, then pass it to , which is a modifier automatically casting the binary number to decimal base and get its ASCII character and  pushes it to stack, Later stack is implicitly outputted.

434 bytes by reusing 'l' and 'o'. This also corrects a capitalization error. Also, your description is incorrect,  outputs a parameter, it does not push to the stack.

Knight, 16 bytes
O"Hello, World!"

Knight is a language made up by some people on my Discord back in April 2021, which is designed to be portable to various programming languages.
Explanation
O is shorthand for OUTPUT, which prints the first argument.
I think you can figure out the rest.

Lispy, 25 bytes
(println "Hello, World!")

This is an implementation of a Lisp invented by Daniel Holden in his book.

Welcome to PPCG! I think you might want to check that byte count.

I accidentally put the lispy binary size instead of the code file. Thanks for the correction :p

How is this encoded? This doesn't look like 4 bytes to me - is this a tokenized language?

Yes it is tokenized. You can read the source on github and its documentation is also available

The documentation doesn't seem to mention any tokenized encoding, and the .bsf files in the repository appear to be encoded unexceptionally. Could you provide a hexdump of your solution, and instructions to run it? (If this is a misunderstanding about what a tokenized encoding means, feel free to correct your byte count to 25.)

Now that you mention, I double checked resources online. It was a misunderstanding on my part. Thank you for the correction, I am new to this. Very appreciate it

Wiselang, 20 bytes
(an esoteric language of mine and BLA4KM4MBA)
eww "Hello, World!";

Lolwho.Cares, 35 bytes
>*2+00210v
^<0210<2`<
Hello, World!

Explanation:
The code is essentially a for loop;
A counter increments, a character is then read from code.
The program exits if this is 0 (end of line), or continues printing.

NOTE, 23 bytes
.print/"Hello, World!"\

Squire, 25 bytes
proclaim("Hello, World!")

Whilst I hath already posteth a "FizzBuzz" program, being the absolute jester I am, I forgoteth to proclaim "Hello, World!" first.
Being themed upon ye olde medieval times, one does not simply "print" in Squire. One must proclaim.

æae, 484 chars
€ââââäââââââââæėâââââäęęęęęęęęęęęęęęęęęęęęęęęęæėâââââäęęęęęęęęęęęęęęęęęæėâââââäęęęęęęęęęęęęęęęęęæėâââââäęęęęęęęęęęęęęęæėâââäâââââââââââââââââæėââââââââââåæėââââäâââââââââââââââââââââââæėâââââäęęęęęęęęęęęęęęæėâââââäęęęęęęęęęęęæėâââââäęęęęęęęęęęęęęęęęęæėâââââäęęęęęęęęęęęęęęęęęęęęęęęęęæ

I've added newlines to clarify which is which:
€                                      < € is required here
ââââäââââââââæ                         < H
ėâââââäęęęęęęęęęęęęęęęęęęęęęęęęæ       < e
ėâââââäęęęęęęęęęęęęęęęęęæ              < l
ėâââââäęęęęęęęęęęęęęęęęęæ              < l
ėâââââäęęęęęęęęęęęęęęæ                 < o
ėâââäâââââââââââââââââæ                < ,
ėââââââââââåæ                          < [space]
ėââââäâââââââââââââââââââââââæ         < W
ėâââââäęęęęęęęęęęęęęęæ                 < o
ėâââââäęęęęęęęęęęęæ                    < r
ėâââââäęęęęęęęęęęęęęęęęęæ              < l
ėâââââäęęęęęęęęęęęęęęęęęęęęęęęęęæ      < d

æae is a language that I made and am implementing as practice for CBL.
Github:
https://github.com/SMARNAV/aeae/

<>^v, 16 bytes
"Hello, World!";

Pushes the string "Hello, World!" to the stack and prints it.
run online

RAMDISP, 18 bytes.
[;[Hello, World!]]

explanation:
[; - print the following values, stringified, and joined.
  [Hello, World!] - an array containing ['H', 'e', 'l', ...]
]

S3C, 13 bytes
Hello, World!
returns Hello, World!
This is a fairly new esolang, but it works for golfing.

The output requires Hello, World! exactly (note the capitalized H).

Also, byte count includes whitespace.

Tictac, 2 bytes
h

Attempt it Online!
Hmm yes just another one of those konstant style answers.
14 bytes
«Hello, World!

Lol

Nevermind, 21 bytes
print,Hello*44 World!

I selected random esolang.

Letters++, 22 bytes
HwEwLwLwO, WwOwRwLwD!p

I selected random esolang.

Uselesslang, 1156 bytes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!@>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!

I will golf more later.
(There is trailing space)

Maybe you can avoid using @ and simply do each char in relation to each other.

@Someone "I will golf more later"

wait...DID YOU POST ON CHRISTMAS!?

@Someone Oh, I did not notice.

str, 17 bytes
`Hello, World!`o;

Try it online!

Byte-based Instruction Jumping, 48 bytes
↑H↑e↑l↑l↑o↑ ↑W↑o↑r↑l↑d↑!

Kotlin, 33 bytes
fun main()=print("Hello, World!")

Try it online!
as usual as it gets... again

FYI, this is a duplicate answer (I believe it's still allowed, as long as you didn't copy it, but just so you know). Also, fun main()= isn't necessary, apparently.

what a coincidence it is that it is same to every single byte. I didn't even see that answer, but I think i will keep it cuz why not. though the no need for the main function thing is going to be useful to me. thanks

I think I'm going to ask that no need for the main function thing at meta

I think the main function is only unneeded there because it can be saved as a .kts (Kotlin "script") file and run directly, which is basically just a variant language of Kotlin. I don't think it really needs a meta discussion (although you can still ask if you want)

the problem is that you can run practically every kotlin program (except probably ones that use advanced libraries, which codegolf really doesn't ask for) as a script too

Binary Lambda Calculus, 14 bytes (30 chars)
Hexdump:
0:2a48656c6c6f2c20576f726c6421

Try it online!

What you have posted is a hexdump of the actual program. The program itself is 14 bytes. (it looks like TIO's byte counter for hexdumps is broken)

Ah ic thx pxeger pls edit my post if i edited it wrongly thx u know more than me!

SMALL, 16 bytes
"Hello, World!"!

! prints the expression before it, giving us the code for this question.

Pyscript, 22 15 bytes
Cheat answer:
'Hello, World!'

Pyscript will behave pretty much like PHP, it will behave just like an interactive terminal. So you if supply a string to the interpreter, it will output the string itself to the rendered html document.
Appropriate answer (22 bytes like Python 3):
print("Hello, World!")

Test it crafting the following HTML file, serving it and rendering with a web browser:
Cheat answer:
<py-script>'Hello, World!'</py-script>

Appropriate answer:

<py-script>
print("Hello, World!")
</py-script>

This is really just a variant of the existing Python answer.

@Ginger This is Hello, World!, half of the answers are the exact same. It's mainly a catalogue of languages.

Welcome to Code Golf, and nice answer!

Pyscript is not technically the same thing as regular Python, I just felt since it'll probably become a mainstream language in the near future, it deserved a place here. And the fact that I found you can strip the print function like in PHP turned out to be more interesting.

Your, 4 bytes
your

This is a weird esolang, basically the number of "your" in your code will yield a different output.

SunSip -w -n, 24 bytes
(just means suppress warnings and no newlines)
set to "Hello, World
out

A big fat 24 bytes.
Syntax highlighted:

Why is the no newlines option nececairy?

SunSIp defaults to newlines appended before output

Trailing whitespace is allowed though

"before""""""""

The word "append" means added after, "prepend" means added before

Also why? Why would you add newlines before instead of after

clear terminal.

m68k machine language, 42 40 36 bytes, tested on SunOS 4.1.4
0x00 4878000d pea 13            ; push length of string to stack
0x04 610e     bsr 0x14          ; push address of string to stack
0x06 48656c6c "Hello, World!\0" ; string
0x0a 6f2c2057
0x0e 6f726c64
0x12 2100
0x14 48780001 pea 1             ; push fd=1 "stdout" to stack
0x18 48780001 pea 1             ; push extra stack slot
0x1c 48780004 pea 4             ; select "write()" syscall
0x20 4e40     trap #0           ; call "write()"
0x22 4e40     trap #0           ; call "exit()"
                                ; write() leaves 1 on stack which is
                                ; used to select exit() syscall.

SunOS appears to be fairly permissive when it comes to arguments of the trap instruction on m68k so this may (untested) work unmodified on NetBSD for m68k.
To try it out, compile and run the following C program.
int main[]={0x4878000d,0x610e4865,0x6c6c6f2c,0x20576f72,
0x6c642100,0x48780001,0x48780001,0x48780004,0x4e404e40};

Fig, \$9\log_{256}(96)\approx\$ 7.408 bytes
D'!>N]JyR

Try it online!

Umm... oops. Seems I forgot that. Fixed

ELF (x86/x64, Linux), 86 bytes
00000000: 7f45 4c46 b001 b20e 488d 3539 0000 003d  .ELF....H.59...=
00000010: 0200 3e00 89c7 eb18 0100 0000 0500 0000  ..>.............
00000020: 1800 0000 0000 0000 1800 0000 0500 0000  ................
00000030: 0f05 29d0 973d 3800 0100 b03c 0f05 0000  ..)..=8....<....
00000040: 0100 b03c 0f05 0000 4865 6c6c 6f2c 2077  ...<....Hello, w
00000050: 6f72 6c64 210a                           orld!.

Try it online!

Num Stack Arithmac, \$165\times\log_{256}(16)=82.5\$ Bytes
++^++++^++++++++q+++++++++++++++++++++++++++++q+++++++qq+++q-%++^-^---^++++++++q------------q%+++^^++++++q++++++++++++++++++++++++q+++q------q--------q%++^-^---^---q

Well, there are actually 13 builtins (Including <> for comments but not all the characters that can go in them). Since people do not like when the \$\log\$ method produces irrational numbers, I have chosen to take the \$\log\$ of 16 instead. If someone knows how to contact the TIO person to add a new programming language, please comment below. Anyways, to run this script in command prompt (>>> denotes what you type in):
>>> pip install num-stack-arithmac
>>> python3
>>> from num_stack_arithmac import compile

Welcome to Num Stack Arithmac!

Enter the filepath or code you want to run (or type "g" for a graphical editor with no support for saving and opening files):

>>> ++^++++^++++++++q+++++++++++++++++++++++++++++q+++++++qq+++q-%++^-^---^++++++++q------------q%+++^^++++++q++++++++++++++++++++++++q+++q------q--------q%++^-^---^---q

Enter the starting number:

>>>

Now the programme will print Hello, World!. The programming language has implicit input. If the programme you are running requires no input, do not enter anything. The starting number will default to 0. You can also type g instead of the code for a window to pop up in which you can paste the code in and run the programme.

So these aren’t log-bytes, but 4-bit builtins, right? I think these are usually called “nibbles”

@Jacob there are actually 13 builtins, 2 used for comments. The community doesn't seem to like irrational log bytes.

To add this to ATO, you can ask pxeger nicely in chat

@TheThonnu i said tio... but sure, ill try.

TIO isn’t maintained much anymore and no longer gets updates—if you want an online version, ATO is your best bet.

There's really no point using nibbles unless you're in competition with other languages (and this seems too much of a tarpit to be so). I'd suggest just having each character be represented by a byte for simplicity's sake

Koka, 31 bytes
fun main()print("Hello world!")

Attempt This Online!

I thought the name of the language was "koala" for a moment!

@Iamkindofalanguagedev This one?

I did not even know that there was a language with that name.

PDP-11 machine language on BSD 2.11, 37 34 bytes
00: 15ce 000d mov $15,(sp) ; len of string on stack
04: 09f7 000e jsr pc, 26   ; addr of string on stack
10: 6548 6c6c              ; "Hello, World!"
    2c6f 5720
    726f 646c
    0021
26: 15e6 0001 mov $1,-(sp) ; stdout on stack
32: 15e6 0001 mov $1,-(sp) ; stack padding
36: 8904      trap 4       ; write() syscall
40: 8901      trap 1       ; exit() syscall

Note that 2BSD does not use the same syscall convention as AT&T UNIXes for the PDP-11. As a result, some previous winners of the IOCCC may not work out of the box on 2BSD.
To try this on a real or emulated PDP-11 running BSD 2.x (this won't work on other operating systems), compile and run the following C program.
char main[]={0xce,0x15,0x0d,0x00,0xf7,0x09,0x0e,0x00,'H','e'
,'l','l','o',',',' ','W','o','r','l','d','!',0x00,0xe6,0x15,
0x01,0x00,0xe6,0x15,0x01,0x00,0x04,0x89,0x01,0x89};

PDP-11 machine language on UNIX v7, 36 bytes
00: 15ce 8901 mov $104401,(sp) ; exit()
04: 15e6 000d mov $15,-(sp)    ; len of string
10: 09f7 000e jsr pc, 32       ; addr of string
14: 6548 6c6c                  ; "Hello, World!"
    2c6f 5720
    726f 646c
    0021
32: 15e6 8904 mov $104404,-(sp); write()
36: 15c0 0001 mov $01,r0       ; fd=1
42: 004e      jmp sp           ; jump to stack

AT&T UNIXes for the PDP-11 had a different syscall convention in which some of the arguments are placed right after the trap instruction. Therefore, almost every syscall requires some self modifying code! The approach here is to generate a "Hello, World!" program on the stack and then jump to the stack.
To try this on a real or emulated PDP-11 running AT&T UNIX, compile and run this C program (if the compiler is very old, remove the =).
char main[]={0xce,0x15,0x01,0x89,0xe6,0x15,0x0d,0x00,0xf7,0x09
,0x0e,0x00,'H','e','l','l','o',',',' ','W','o','r','l','d','!'
,0x00,0xe6,0x15,0x04,0x89,0xc0,0x15,0x01,0x00,0x4e,0x00};

{,}, 2279 Chars or \$2279\log_{256}(4)\approx\$ 569.75 Bytes
({(())},()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())

Completely ungolfed (for now)

{High}, 16 bytes
"Hello, World!";

Two new languages at once!

Noulith, 15 bytes
"Hello, World!"

Implicitly outputs the string.
https://betaveros.github.io/noulith/#IkhlbGxvLCBXb3JsZCEi

MetaBrainfuck -x, (22 bytes)
"Hello, World!"{{+}.>}
Explanation
"Hello, World!"{     }     # for each character in the string "Hello, World!"
                {+}.>      # repeat + that many times, then append .>

expands to the following Brainfuck program:
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++.>

which when executed (-x flag) prints Hello, World!

WE32k machine language on AT&T UNIX System V, 37 34 bytes
00:  84 4c 4a             MOVW  %sp,%ap     ; set argument pointer for upcoming sycall
03:  a0 01                PUSHW &0x1        ; push file descriptor = 1 to stack
05:  37 0f                BSBB  0xf <0x14>  ; push address of string to stack
07:  48 65 6c 6c 6f 2c 20                   ; "Hello, World!"
0f:  57 6f 72 6c 64 21
14:  a0 0d                PUSHW &0xd        ; push length of string to stack
16:  84 20 41             MOVW  &0x20,%r1   ; select write()
19:  84 04 40             MOVW  &0x4,%r0    ; configure GATE for syscall
1c:  30 61                GATE              ; syscall
1e:  84 08 41             MOVW  &0x8,%r1    ; select exit() syscall
21:  7b f8                BRB   -0x8 <0x19> ; goto 0x19

To try this on an emulator or actual AT&T 3B2 hardware, compile and run the following C program.
char main[]={0x84,0x4c,0x4a,0xa0,0x01,0x37,0x0f,
'H','e','l','l','o',',',' ','W','o','r','l','d','!'
,0xa0,0x0d,0x84,0x20,0x41,0x84,0x04,0x40,0x30,0x61
,0x84,0x08,0x41,0x7b,0xf8};

TIL you could write machine code as C by defining main as a char array

@Somebody this technique has a somewhat famous history

IBM z/Architecture machine language on Linux, 31 bytes
00:   a7 29 00 01         lghi    %r2,1.          # fd=1
04:   c0 30 00 00 00 07   larl    %r3,742 <+0x12> # set address of string
0a:   a7 49 00 0d         lghi    %r4,13          # set length of string
0e:   0a 04               svc     4               # write() syscall
10:   0a 01               svc     1               # exit() syscall
12:   48 65 6c 6c                                 # "Hello, World!"
16:   6f 2c 20 57
1a:   6f 72 6c 64
1e:   21

To try this on an emulator or actual machine, compile and run the following C program.
const char main[] __attribute__((section("rodata")))=
"\xa7\x29\x00\x01\xc0\x30\x00\x00\x00\x07\xa7\x49\x00"
"\x0d\x0a\x04\x0a\x01Hello, World!";

On a 31 bit machine (or 64 bit machine in 31 bit mode) change the lghi instructions to lhi which can be done by clearing the 16th most significant bit (0x29 becomes 0x28; 0x49 becomes 0x48).

m4, 13 bytes
Hello, World!

Try it online!
Trivial solution!

Super Stack!, 66 bytes
0 33 100 108 114 111 87 32 44 111 108 108 101 72 if outputascii fi

Pushes the letters followed by a zero onto the stack, and prints them while they aren't zero.

SSBPL, 33 bytes
0'!'d'l'r'o'W' ','o'l$'e'H[$][.]#

This pushes the ASCII for "Hello, World!" followed by a 0 onto the stack, then prints the top value while it isn't zero.

AutoIt, 29 bytes
ConsoleWrite("Hello, World!")

Needs to be compiled as a console program.

MsgBox(0,"","Hello, World!") is one shorter :)

Foobar and Foobaz and Barbaz, oh my!, 314 bytes
72 and 72 and 0, oh my.
37 and 37 and 64, oh my.
72 and 72 and 36, oh my.
. and 64 and 44, oh my.
67 and 67 and 44, oh my.
. and 44 and 0, oh my.
. and 32 and 0, oh my.
87 and 87 and 0, oh my.
40 and 40 and 71, oh my.
16 and 16 and 98, oh my.
12 and 12 and 96, oh my.
. and 64 and 36, oh my.
1 and 1 and 32, oh my.

I believe that this is an optimal solution, with each line outputting a character.

Swap, 13 bytes
Hello, World!

Similar to ///, but swaps the terms instead of replacing them.

J--, 28 bytes
main{echo("Hello, World!");}

main is replaced with public static void main(String[]a), echo is replaced with System.out.println, and the entire program is put in a class.

A0A0, 57 bytes
P72P87
P101P111
P108P114
P108P108
P111P100
P44P33
P32
G-6

2 commands per line was the densest packing that I could find.

I get Hl,Wrdeo ol! as the output from this...

@Sp3000 Should be fixed

Ans, 16 bytes
$"Hello, World!"

$ is the standard output mechanism.

Tarflex, 18 bytes
outs Hello, World!

outs is the standard output mechanism.

WARP, 16 bytes
)"Hello, World!"

) is the standard output mechanism.

ACIDIC, 16 bytes
Hello, World!
+*

Prints the entire storage stack, which is filled with Hello, World!.

Argh!, 27 bytes
ppppppppppppp
Hello, World!

Each p prints the character below it.

STXTRM, 15 bytes
[Hello, World!]

[...] is the standard output mechanism.

ZeptoBasic, 21 bytes
print "Hello, World!"

print is the standard output mechanism.

rs, 14 bytes
/Hello, World!

Replaces the empty string with "Hello, World!"

EEL, 93 bytes
(Also known as Extensible Esoteric Language)
def(z|-1;x;z)
def(d|c;z)
72
d
101
d
108
c
d
111
d
44
d
32
d
87
d
111
d
114
d
108
d
100
d
33
d

I'm sure this could be golfed quite a lot, but this is something I whipped up pretty quick. All it does is define some helpful functions and use them to display "Hello, World!"
Also, this DOES print "Hello, World!" with the characters separated by newlines, but I can't do anything about that, it's impossible in EEL.

its obviously not that extensible if you can't do the challenge...

~English, 29 bytes
Display "Hello, World!".Stop.

0815, 92 80 bytes
<:48:~$<:65:~$<:6C:~$$><:6F:~$>@<:2C:~$<:20:~$<:57:~${~$<:72:~${~$<:64:~$<:21:~$

Wat, 47 + 1 = 48 bytes
0«!dlroW ,olleH»>ó#ÐÑÅv
                ^     ó#ÐÑÅv

0«!dlroW ,olleH»        Push a reversed null terminated string
                >       Go forward
                 ó      Duplicate the top of stack
                  #     Skip the next instruction
                   Ð    Kill all "execution engines" (end the program)
                    Ñ   If the top of the stack is 0, go backward (execute Ð and end the program), otherwise go forward
                     Å  Print the character on the top of the stack
                      v Go downward
Second line:

                ^     <

Simply loop from the 'v' to the '>'

Fith, 17 bytes
"Hello, World!" .

. is the print word.

Doesn't that thing have any documentation???

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ  Documentation is in progress. Don't let the one-byte instruction fool you - this lang is terrible for golfing.

Arithmescript, 42 bytes
Try it here!
Golfed:
var input = "";add("Hello, World!");out();

Ungolfed:
var input = "";
add("Hello, World!");
out();

This defines the input as nothing, adds the string Hello, World!, and then alerts it (you can't log to console as of now)
Technically this is 379 bytes, as v1.0 had a bug where not embedding the programming language interpreter led to not being about to change the input variable.
Requires Arithmescript v1.0 or higher

Arithmescript, 27 bytes
Try it here!
Golfed:
add("Hello, World!");out();

Ungolfed:
add("Hello, World!");
out();

v1.1 of Arithmescript automatically defines the input variable, so we use less bytes!
Requires Arithmescript v1.1 or higher

Arithmescript, 11 bytes
Try it here!
Golfed:
hw();out();

Ungolfed:
hw();
out();

Arithmescript has a function that works the same as add("Hello, World!") but is shorter and takes no parameters.
Requires Arithmescript v1.1 or higher

If you're wondering, Arithmescript is a programming language written in JavaScript for golfing. Technically, it's not a programming language, but it is. You can view the sources of v1.0 and v1.1.

eacal, 24 bytes
put string Hello, World!

Simple enough. put prints its argument, string turns its arguments into a string entity.

Node.js REPL, 20 bytes
throw"Hello, World!"

Output:
> throw"Hello, World!"
Hello, World!

Does this satisfy the •Each submission must be a full program. requirement?

Arc, 21 bytes
(prn "Hello, World!")

PAWN, 29 bytes
main()
print"Hello, World!\n"

(no trailing newline)
Originally I was looking how to get QuadPawn (video) installed on my handheld scope but it turned out that my scope's hardware version (V2.72/8MB) isn't supported... :-(
Someone else wants to try this?
Luckily getting Pawn compiler 4.0.5504M from https://github.com/compuphase/pawn compiled on Debian-8.5/AMD64 was not a big deal.
That way I could run/verify these two lines.

reticular, 17 bytes
"Hello, World!"p;

This has a trailing newline.
This doesn't:
"Hello, World!"o;

Is there any documentation for Reticular?

@Chance yup. Follow the link in the header, then go to the Github wiki.

Logy, 32 bytes
main[_]->print["Hello, World!"];

Define the rule main printing Hello, World!.
EDIT: Now puts need to be included, so I need to use print

MATLAB, 20 bytes
disp 'Hello, World!'

This is one byte shorter than the standard disp('Hello, World!').

disp 'Hello, World!' is one byte shorter!

Y, 19 bytes
∅O("Hello, World!")

Call the special function O (output) with the string Hello, World!

Ruby, 19 Bytes
$><<"Hello, World!"

The rules sais it should print "this exact byte stream, including capitalisation and punctuation) plus an optional trailing newline, and nothing else". Your solution prints the string with qoutes around it.

@daniero Fixed
There is one alternate answer but while on repl it also prints additonal info but when run from a script outputs exact answer
$><<"Hello, World!"

@daniero Sorry, pressed enter without completing the response
ruby -e "$><<"Hello, World!"

Your solution is now identical to this one :P http://codegolf.stackexchange.com/a/55443/4372. But the $><< variant is the same length, so I'd go with that, unless that solution also already exists

@daniero Modified the answer :]

JLisp, 23 bytes
(write "Hello, World!")

Call the write function, which print a text to stdout

Stackish, 20 bytes
Hey, a competing answer!
"!dlroW ,olleH",l15'

Simple stack stuff.

NetLogo, 20 bytes
print"Hello, World!"

Lily, 22 bytes
Pretty darn similar to a lot of other languages.
print("Hello, World!")

Here's a Tio example to play with.

2sable, 14 bytes
"Hello, World!

Extremely straightforward.
Try it online!

fish, 18 bytes
echo Hello, World!

Try it online!

PicoLisp, 26 bytes
(prin"Hello, World!")(bye)

Try it online!

Racket, 24 bytes
(display"Hello, World!")

Try it online!

Glee, 15 bytes
"Hello, World!"

This creates a character vector/string, which gets printed to the output.

JQuery, 222 214 194 147 113 bytes
Saved 20 bytes thanks to ais523 and 34 thanks to Matheus Avellar.

Just because it's JQuery. You can't get enough JQuery :D

Why not shorten the div id to a single character to save some bytes? Also, you might be able to make that a self-closing div.

@numbermaniac You can't use self-closing divs in HTML.

Ah, alright then, my mistake.

Couldn't you just leave off the closing tags altogether, though? Browsers will add them implicitly (and this is actually specified in the most recent versions of HTML).

Here this will work better codegolf wise:
 (tested on w3schools)

NotQuiteThere, 17 bytes
'Hello, World!'-1

Try it online!

Add++, 70 20 bytes
D,f,,"Hello, World!"

Try it online!
Simple function, implicit call and return. You can see the revision history for the old version.

17?

Small, 1552 bytes
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.

A joke language at https://esolangs.org

Pyffman 1, 16 bytes
The code contains lots of unprintable characters, so here's a hexdump:
00000000: 78c2 40a6 9a7a 5d51 7d8e 87cf 617d cf3d  x.@..z]Q}...a}.=

To obtain the original source code, put the hexdump in a file and call xxd -r on it.

Foam, 17 bytes
<'|Hello, World!|

<' grabs the next token from the source code an outputs it with a trailing newline. The next token is Hello, World! (It is wrapped in bars so that the space can be added without it being treated like another token.

nouse, 321 bytes
I can't figure out from the spec how to specify operands in Line Noise syntax.  If anyone knows please comment.
Here is the Assembly syntax version:
cut 0,72,write 0,paste 0
cut 0,101,write 0,paste 0
cut 0,108,write 0,write 0,paste 0
cut 0,111,write 0,paste 0
cut 0,44,write 0,paste 0
cut 0,32,write 0,paste 0
cut 0,87,write 0,paste 0
cut 0,111,write 0,paste 0
cut 0,114,write 0,paste 0
cut 0,108,write 0,paste 0
cut 0,100,write 0,paste 0
cut 0,33,write 0,paste 0
swap 0

HTML & JS (w/ jQuery), 85 bytes

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/