"Hello, World!"

336

110

So... uh... this is a bit embarrassing. But we don't have a plain "Hello, World!" challenge yet (despite having 35 variants tagged with , and counting). While this is not the most interesting code golf in the common languages, finding the shortest solution in certain esolangs can be a serious challenge. For instance, to my knowledge it is not known whether the shortest possible Brainfuck solution has been found yet.

Furthermore, while all of Wikipedia (the Wikipedia entry has been deleted but there is a copy at archive.org ), esolangs and Rosetta Code have lists of "Hello, World!" programs, none of these are interested in having the shortest for each language (there is also this GitHub repository). If we want to be a significant site in the code golf community, I think we should try and create the ultimate catalogue of shortest "Hello, World!" programs (similar to how our basic quine challenge contains some of the shortest known quines in various languages). So let's do this!

The Rules

  • Each submission must be a full program.
  • The program must take no input, and print Hello, World! to STDOUT (this exact byte stream, including capitalization and punctuation) plus an optional trailing newline, and nothing else.
  • The program must not write anything to STDERR.
  • If anyone wants to abuse this by creating a language where the empty program prints Hello, World!, then congrats, they just paved the way for a very boring answer.

    Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.

  • Submissions are scored in bytes, in an appropriate (pre-existing) encoding, usually (but not necessarily) UTF-8. Some languages, like Folders, are a bit tricky to score - if in doubt, please ask on Meta.
  • This is not about finding the language with the shortest "Hello, World!" program. This is about finding the shortest "Hello, World!" program in every language. Therefore, I will not accept an answer.
  • If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainfuck-derivatives like Alphuck), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.

As a side note, please don't downvote boring (but valid) answers in languages where there is not much to golf - these are still useful to this question as it tries to compile a catalogue as complete as possible. However, do primarily upvote answers in languages where the authors actually had to put effort into golfing the code.

For inspiration, check the Hello World Collection.

The Catalogue

The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.

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

## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:

## [><>](https://esolangs.org/wiki/Fish), 121 bytes

/* Configuration */

var QUESTION_ID = 55422; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.

/* App */

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

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

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

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

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

getAnswers();

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

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

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

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

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

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

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

table thead {
  font-weight: bold;
}

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

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

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

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

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

1@isaacg No it doesn't. I think there would be some interesting languages where it's not obvious whether primality testing is possible. – Martin Ender – 2015-08-28T13:56:09.300

4If the same program, such as "Hello, World!", is the shortest in many different and unrelated languages, should it be posted separately? – aditsu – 2015-08-28T15:33:49.897

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

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

1@mbomb007 Well it's hidden by default because the three code blocks take up a lot of space. I could minify them so that they are a single line each, but I'd rather keep the code maintainable in case bugs come up. – Martin Ender – 2015-08-28T19:34:40.853

7@Sp3000 I'm fairly certain the universe would end before a Seed program would be found by brute force for the current smallest Befunge "Hello, World!" program. – mbomb007 – 2015-08-28T19:45:12.883

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

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

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

4@ETHproductions "Unlike our usual rules, feel free to use a language (or language version) even if it's newer than this challenge." Publishing the language and an implementation before posting it would definitely be helpful though. – Martin Ender – 2015-08-29T23:01:10.023

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

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

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

The Wikipedia link has been deleted, but the deletion discussion also pointed out here.

– LegionMammal978 – 2015-09-27T22:07:29.660

@LegionMammal978 Thanks for letting me know. – Martin Ender – 2015-09-27T22:11:06.273

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

@LegionMammal978 Yes.

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

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

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

3@Sp3000 For completeness, about how big a bounty would you put up if somebody answered in Seed? 200? 500? – wizzwizz4 – 2015-12-28T18:21:31.627

1

@wizzwizz4 It's listed here, but 500. GL!

– Sp3000 – 2015-12-29T09:18:11.363

@Sp3000 I got it if you replace Befunge in the Seed specification with HQ9: 1 92. – KSFT – 2016-01-04T23:47:18.117

1@KSFT except HQ9+ doesn't print the correct version of the string. – Martin Ender – 2016-01-04T23:57:13.863

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

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

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

96 bytes for a Ruby answer? What kind of enterprise coding are you doing? – Nic Hartley – 2016-04-06T21:45:37.043

7It would take 55509645297757087575506149 days and 14 hours to compute the seed solution. – Bald Bantha – 2016-05-16T15:08:58.377

Can someone please create an index snippet for this. – Titus – 2016-10-05T13:52:52.683

@Titus like the one at the bottom of the post? I'm not sure what you mean. – Martin Ender – 2016-10-05T14:02:31.673

2

@Sp3000 feersum did it: http://codegolf.stackexchange.com/a/97842/42545

– ETHproductions – 2016-10-28T15:06:49.090

3Shouldn't this be unprotected? – Oliver Ni – 2016-11-04T04:44:30.423

@BaldBantha If Moore's law holds, it would take about a year to find a seed solution if you wait about 115 years to start it. – KSmarts – 2017-12-11T18:29:02.110

Answers

360

Stuck, 0 bytes

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

Fatalize

Posted 2015-08-28T12:23:59.027

Reputation: 24 736

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

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

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

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

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

3This is hilarious! LOL! – Oliver Ni – 2015-10-16T17:13:49.587

20 bytes... haha Stuck – Star OS – 2015-12-15T12:27:10.890

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

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

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

@10Replies ok but you gotta drop this and use jquery it’s reallyyyy good there’s a plug-in for this – Stan Strum – 2018-03-06T19:46:32.400

200

Brainfuck, 78 bytes

Open-ended bounty: If anyone can improve this score, I will pass the bounty (+500) on to them.

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

Try it online!

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

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

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

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

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

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

I've also found an alternative 78 byte solution:

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

Try it online!

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


More Detail

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

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

which represents:

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

with

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

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


Other Examples

Fibonacci Sequence

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

N-gonal Numbers

Triangular Numbers

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

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

Square Numbers

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

Pentagonal Numbers

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

etc.


BF Crunch

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

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

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

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

Output is given in three lines:

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

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

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

This corresponds to the full program:

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

Other Records

Hello, World!

Wrapping, 78 bytes:

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

or

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

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

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

Hello, world!

Wrapping, 80 bytes:

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

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

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

hello, world!

Wrapping, 74 bytes:

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

Non-wrapping, 84 bytes:

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

Esolangs Version

Hello World!\n

Wrapping, 76 bytes:

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

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

Non-wrapping, 83 bytes:

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

Rdebath approved. profilebf output:

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

inversed.ru (Peter Karpov)

Hello World!

Wrapping, 70 bytes (previously 781):

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

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

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

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

hello world!

Wrapping, 65 bytes (previously 66 bytes):

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

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

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

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

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

primo

Posted 2015-08-28T12:23:59.027

Reputation: 28 050

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

3@MitchSchwartz You sniped my anagol ;) – primo – 2016-01-03T17:36:27.317

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

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

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

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

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

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

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

195

PHP, 13 bytes

Hello, World!

Yes. It works.

georgeunix

Posted 2015-08-28T12:23:59.027

Reputation: 2 573

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

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

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

69@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 – georgeunix – 2015-08-29T11:43:34.897

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

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

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

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

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

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

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

194

ArnoldC, 71 bytes

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

Just for lols..

AlCode

Posted 2015-08-28T12:23:59.027

Reputation: 2 041

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

1@JelloDude Yeah. – None – 2015-08-30T06:45:11.650

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

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

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

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

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

157

Seed, 6016 4234 4205 bytes

20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793

The resulting Befunge-98 program (based on this) is

"9!dlroW ,olleH"ck,@

feersum

Posted 2015-08-28T12:23:59.027

Reputation: 26 090

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

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

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

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

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

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

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

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

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

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

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

1

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

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

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

2

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

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

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

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

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

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

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

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

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

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

132

Mornington Crescent, 3614 bytes

Take Northern Line to Hendon Central
Take Northern Line to Bank
Take Northern 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 Victoria Line to Victoria
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Cannon Street
Take District Line to Hammersmith
Take District Line to Cannon Street
Take District Line to Bank
Take District 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 Piccadilly Line to Acton Town
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take District 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 Victoria 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 District 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 District 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 District 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 District 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 District 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 District Line to Paddington
Take District 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 District Line to Paddington
Take District Line to Richmond
Take District Line to Bank
Take District 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 District Line to Notting Hill Gate
Take District 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. I have tested this with the interpreter in the Esoteric IDE.

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

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

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

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

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

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

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

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

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

2

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

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

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

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

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

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

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

110

evil, 70 bytes

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

It uses the following four commands:

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

grc

Posted 2015-08-28T12:23:59.027

Reputation: 17 685

49That is evil... – David Grinberg – 2015-09-01T14:18:35.230

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

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

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

4

@KishanKumar yes

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

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

3

@KishanKumar there's a java implementation here.

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

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

78

Piet, 90 codels

enter image description here

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

enter image description here

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

Edit: @primo's 84 codel solution.

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

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

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

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

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

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

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

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

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

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

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

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

7

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

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

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

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

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

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

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

75

Haystack, 17 Bytes

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

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

"Hello, World!"o|

Bonus: A more exciting version:

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

Kade

Posted 2015-08-28T12:23:59.027

Reputation: 6 148

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

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

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

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

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

23>;+o​​​​​​​​​​​ – bjb568 – 2015-09-13T00:10:53.430

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

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

64

Help, WarDoq!, 1 byte

H

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

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

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

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

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

4

@TimmyD Nope, not HQ9++.

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

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

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

22

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

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

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

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

59

MarioLANG, 259 249 242 240 235 bytes

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

This has been tested in the Ruby implementation.

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

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

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

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

Metagolf

Time for some automation...

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

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

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

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

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

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

4+1 for the metagolf – justhalf – 2015-08-29T14:39:39.273

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

+1 for using MarioLANG – None – 2017-06-10T00:23:33.213

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

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

52

Chef, 465 bytes

H.

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

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

Serves 1.

Tested with the Ruby interpreter. Makes alphabet soup.

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

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

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

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

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

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

48

Dark, 106 bytes

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

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

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

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

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

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

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

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

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

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

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

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

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

46

Piet, 84 codels

Piet Hello World

28x3, here shown with codel width 10.

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

Piet Layout

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

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

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

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

primo

Posted 2015-08-28T12:23:59.027

Reputation: 28 050

1+1 Nice small solution! – M L – 2015-12-24T12:49:08.877

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

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

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

45

Whitespace, 192 150 146 bytes

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

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

Hexdump of code

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

Whitespace assembly code:

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

Remarks:

I had to write a program just to calculate that adding 107 gives the optimal golf for the sentence. Since the bytesize that an integer takes in the code changes. : 4+int(abs(log2($n)))
The code will still run without the "e:" label & exit part on whitespace.kauaveel.ee. But that could make the whitespace code invalid on other whitespace compilers. So those bytes weren't golfed out from the solution.

LukStorms

Posted 2015-08-28T12:23:59.027

Reputation: 1 686

44

Java, 79

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

Earlier versions of Java may allow you to use a static block (51 bytes), but currently I don't know of a way to bypass the main method.

Geobits

Posted 2015-08-28T12:23:59.027

Reputation: 16 001

The static block trick resulted in something being written to stderr, which is not acceptable here. – aditsu – 2015-08-28T16:17:30.170

Ah, right. I was thinking there was something like that, so didn't post the actual code. Didn't have version <7 at hand to test, though. – Geobits – 2015-08-28T16:19:50.503

6Use enum instead of class. – Thomas Eding – 2015-08-29T07:41:20.930

6

@ThomasEding What compiler does that actually work on? I've tried this tip on several, and have never been able to save bytes with it.

– Geobits – 2015-08-29T15:57:12.530

I know I've recently seen an example of using an enum to bypass the main call somewhere around here. Only worked for Java 1.5 though. – Luminous – 2015-09-01T13:29:15.987

4@Luminous Ah, it might have worked for 1.5. I'm not going to install it to find out, though, but stick to something released in the last 10 years. If I never see Java 5 again it'll be a nice life :) – Geobits – 2015-09-01T13:34:12.813

1Processing (also java): print("Hello, World!"); – TheDoctor – 2015-09-01T23:48:35.813

2@TheDoctor From what I've seen, Processing is usually seen as a separate language here. You should post it as an answer, or at least ask for clarification from the OP. – Geobits – 2015-09-02T00:41:11.100

@Geobits That's why I didn't post it as an answer. – TheDoctor – 2015-09-02T01:50:33.773

2@ThomasEding Declaring it as an enum would require a semicolon at the start of the class body, since it's required to start with type declarations. It would still come out to 79 bytes. – caseif – 2015-09-04T17:04:10.453

4

User OptiFine suggested saving 3 bytes by using an interface and ditching the public specifier. I've rejected the edit following policy but since they can't comment, I thought I'd let you know so you can use it if you like.

– Martin Ender – 2016-04-07T09:09:45.067

1U may be able to use interface than a class in Java 8 – Sudara – 2016-10-13T05:35:26.957

Beaten by TheNumberOne's answer with -3 bytes.

– Steven Vascellaro – 2017-09-14T16:07:31.360

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

– Olivier Grégoire – 2017-09-20T07:48:54.613

42

CSS, 30 bytes

:after{content:"Hello, World!"

Cascading Style Sheets (CSS) isn't a typical programming language, but it can do fixed output fairly well. This is done by creating a pseudo-element after every element with the content Hello, World!. So only one element (<html>) is selected, this assumes that we're using the most basic HTML document, i.e.

<html><style>:after{content:"Hello, World!"</style></html>

This works in most major browsers, with the notable exception of Firefox, which applies the selector to the <html> and <body> elements. This is also why Stack snippets don't work, because there is always a body element that gets styled as well. Below is a slightly modified version to test.

* :after{content:"Hello, World!"

NinjaBearMonkey

Posted 2015-08-28T12:23:59.027

Reputation: 8 395

3You can also use * * to select body. – jimmy23013 – 2015-08-31T07:50:15.643

15@jimmy23013 That sounds gloriously inefficient. Thanks – NinjaBearMonkey – 2015-08-31T18:09:31.893

1For whatever reasons * :after also seemed to work. – jimmy23013 – 2015-09-01T02:20:28.647

@jimmy23013 Um... of course? * :after means the :after content insertion point of an element that has any element (*) in its ancestor tree. That's why you can do stuff like div a: an a element that has a div as one of its ancestors. – Toothbrush – 2015-09-04T17:55:36.930

1@toothbrush I know it is by design, but that just doesn't mean I like it. Intuitively, body::after is in body just like div a in div. – jimmy23013 – 2015-09-04T18:08:01.073

@jimmy23013 Yeah, I agree. It isn't intuitive that you apply ::after to the element you want to insert the content into. – Toothbrush – 2015-09-04T18:19:52.473

8I'm asking my self which of the letters in CSS is the abrreviation for "language". – Zaibis – 2015-09-07T14:27:35.027

5@zaibis the same letter for PHP probably :) – fcalderan – 2017-02-02T22:55:46.657

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

– arodebaugh – 2017-05-09T16:11:56.623

41

HTML, 13 bytes

Hello, World!

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

jrich

Posted 2015-08-28T12:23:59.027

Reputation: 3 322

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

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

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

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

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

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

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

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

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

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

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

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

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

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

39

Homespring, 58 bytes

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

The trailing space is significant.

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

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

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

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

11This is...weird... – refi64 – 2015-09-03T22:35:19.593

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

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

1This is my new favorite language. – Mega Man – 2017-07-08T12:23:16.940

39

Hexagony, 37 32 bytes

Notice: I'll be giving a bounty of 500 rep to the first person who finds a valid solution in a hexagon of side-length 3 or a provably optimal solution of side-length 4. If you can't find such a solution but manage to beat my score in a side-length 4 hexagon (by getting more no-ops at the end of the program, which can be omitted from the source code), I'm willing to give out a smaller bounty for that as well.

H;e;P1;@/;W;o;/l;;o;Q/r;l;d;2;P0

Try it online!

I proudly present my second 2D programming language, and (to my knowledge) the first ever 2D language on a hexagonal grid.

The source code doesn't look very 2D, does it? Well, whitespace is optional in Hexagony. First, the source code is padded to the next centred hexagonal number with no-ops (.). The next such number is 37, so we insert five no-ops at the end. Then the source code is rearranged into regular hexagon:

   H ; e ;
  P 1 ; @ /
 ; W ; o ; /
l ; ; o ; Q /
 r ; l ; d ;
  2 ; P 0 .
   . . . .

This is also runnable. Try it online!

Hexagony has a bunch of pretty funky features, including 6 different instruction pointers and a memory layout which is the line graph of a hexagonal grid, but this code uses only one IP and one memory edge, so let's not worry about that for now.

Here is an overview over the relevant commands:

  • Letters just set the current memory edge to their ASCII value
  • ; prints the current value, modulo 256, as a byte to STDOUT.
  • / is a mirror which behaves as you'd expect (causing the IP to take a 120 degree turn).
  • Digits work as they do in Labyrinth: they multiply the current cell by 10 and then add themselves.
  • @ terminates the program.

Now the final catch is that the source wraps around all 3 pairs of edges. Furthermore, if the IP leaves the grid through one of the six corners, there are two possible rows to jump to. Which one is chosen depends on whether the current value is positive or non-positive. The following annotated version shows where the IP re-enters each time it leaves the grid:

         H ; e ;     -> 1
5 ->    P 1 ; @ /    -> 4
3 ->   ; W ; o ; /   -> 2
1 ->  l ; ; o ; Q /
4 ->   r ; l ; d ;   -> 5
2 ->    2 ; P 0 .    -> 3
         . . . .

So if we remove all the direction changes, this program boils down to the following linear code:

H;e;l;;o;Q2;P0;W;o;r;l;d;P1;@

What's with Q2, P0 and P1? Letters are printed easily because we can just set the edge to the corresponding value. For the comma, the space and the exclamation mark, that doesn't work. We also can't just set their value with 44, 32, 33, respectively, because the memory edge is non-zero to begin with, and due to the semantics of individual digits that would wreak all sorts of havoc. If we wanted to do that, we'd have to reset the edge value to zero with something like *, +, -, & or ^ first. However, since the value is taken modulo 256 before being printed we don't have to set the values exactly to 44, 32, or 33. For instance, Q2 will set the edge value to 81*10 + 2 = 812, which is 44 when taken modulo 256. This way we can save a byte on each of those three characters. (Unfortunately, it's never possible to get there with a single digit from the value the cell already has. Amusingly, where it does work is the o in World, because that can also be obtained from W9.)

You can use this CJam script to find all letter-digit combinations that result in a given character.

I'm not sure whether this is optimal. I doubt it's possible to do it in a hexagon of side-length 3 (where you'd only have 19 characters available), but it might be possible to solve it in a hexagon with side-length 4 with less than 32 commands, such that there are more no-ops at the end of the grid.

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

1Dammit, you beat me to it. I myself am working on a hexagonal language kind of similar to Cardinal. – M L – 2015-09-14T16:49:36.200

How did you find this solution? By hand or brute-force? Anyway, +1 :) – Adnan – 2016-01-25T15:19:19.430

@Adnan By hand. It's the simplest linear layout you could possibly have, I think. (I did write a CJam script to find combinations of letter + digit that give ,, space and ! if that's what you're asking. There are two solutions for each of them.) – Martin Ender – 2016-01-25T15:20:01.717

1The Q2, P0 and P1 is very clever. I didn't know the modulo 256 part. – Adnan – 2016-01-25T15:27:57.387

1@Adnan The person who suggested the mod-256 part on GitHub actually did so along with the example that linefeeds could then be printed as M8; (or g4;), which I've used a couple of times since then. It just never occurred to me until now to revisit this answer after I made that change. – Martin Ender – 2016-01-25T15:29:21.220

And it just shortend this submission by 5 bytes easily. I have also spent some time to actually golf this, but I didn't succeed and never actually came up with this. I will think of this in the future though :). – Adnan – 2016-01-25T15:52:46.357

2

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

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

38

x86_64 (Unix), 32 bytes

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. Of course, this will only work on Unix systems.

grc

Posted 2015-08-28T12:23:59.027

Reputation: 17 685

34

Malbolge, 112 bytes

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

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

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

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

Jacob

Posted 2015-08-28T12:23:59.027

Reputation: 711

33

Fourier, 15 bytes

BIG CHANGES to Fourier!

`Hello, World!`

Try it on FourIDE!

Yes, the days of typing out the ASCII code of each character are gone forever: Fourier now kind of supports strings. When you enclose a string in backticks, that string will be outputted.

Note that you can't do anything other than output that string: you cannot store it in a variable, it is not stored in the accumulator and there are no string manipulation tools.


Here, you can find the train wreck that was old Fourier. ;)

72a101a+7aa+3a44a32a87a111a+3a-6a-8a33a

Try it online!

Now, some of you will probably have met Fourier before and may be fairly familiar with the language. The whole language is based upon an accumulator: a global variable which pretty much all operators use.

The most important part of the code is the a operator. This takes the numerical value of the accumulator and converts it to a character using the Python code chr(accumulator). This is then printed to STDOUT.

Unfortunately, I haven't had the chance to use Fourier yet (nudge nudge, wink wink), mainly because of its lack of strings and string operators. Even so, it's still usuable for many other challenges (see the examples section of its EsoLangs page).

Note that this is shorter than my entry into the Esolangs list because I didn't actually think that I could golf it any more. And then, when writing the Fourier string golfing challenge, I realised I could go quite a bit shorter.

Note

If you were wondering about variable syntax, Geobits wrote a program which uses variables and is the same length:

72a101a+7aa+3~za44a32a87aza+3a-6a-8a/3a

Try it online!

Beta Decay

Posted 2015-08-28T12:23:59.027

Reputation: 11 590

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

32

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

refi64

Posted 2015-08-28T12:23:59.027

Reputation: 7 567

8Really fascinating language - I'd never heard of it before, and it's certainly an ambitious project that they (were/are) doing. But in terms of code golf, I don't think it'll be a contender. I mean ... dang, this thing loses to Java ... – AdmBorkBork – 2015-08-28T20:20:50.857

10@TimmyD It's really an assembler. There's a reason it loses to Java... :) – refi64 – 2015-08-28T20:21:23.790

29

Befunge 98, 19 18 Bytes

New answer (from undergroundmonorail)

"ck,@!dlroW ,olleH

Explanation

  • " starts string mode
  • Everything that follows is pushed to the stack. The stack is now Hello, World!@,kc
  • After hitting the end, interpreter go back to the start
  • It encounters " again, ending string mode
  • 12 is pushed to the stack (c)
  • k takes the top value of stack and executes the next command the instruction pointer can see that many times
  • , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
  • @ ends the program

The difference with the old answer is that we cleverly reuse the " character by using Befunge's looping behavior when it hits the end of the line. Since it might be less intuitive, I'm letting the old one as well. Also, you may have noticed that the stack will still contains some characters (ck,@) because of this nice trick, leaving some mess if we ever wanted to do something after that.

Old Answer

"!dlroW ,olleH"ck,@

This works for funge and befunge 98

Explanation

  • Everything between "" is pushed to the stack. ('H' is now on top.)
  • c (12) is pushed to the stack
  • k takes the top value of stack and executes the next command the instruction pointer can see that many times.
  • , pops a value from stack and outputs it as a char. It has been executed 12 times by last k instruction, and one time more when the interpreter actually reads the , instruction
  • @ ends the program

Luke Marlin

Posted 2015-08-28T12:23:59.027

Reputation: 391

2I don't think 93 has k – Sp3000 – 2015-08-28T14:30:44.870

@Sp3000 Checked the spec, you are right. I thought that p was missing. It's the opposite. Thanks. – Luke Marlin – 2015-08-28T14:34:40.260

1Well, now that it's 98 only you can use c for 93+. – Pietu1998 – 2015-08-28T19:52:40.067

@Pietu1998 Indeed, nice one. – Luke Marlin – 2015-08-31T13:17:38.250

3In 18: "ck,@!dlroW ,olleH – undergroundmonorail – 2015-09-25T19:07:54.227

@undergroundmonorail I have to admit that I don't get the behavior of funge here. Does it empty the stack after hitting @, and interprets what is in it ? – Luke Marlin – 2015-09-28T12:15:39.967

1It hits the " to start the string, adds the entire rest of the line to that string, wraps around and hits the same " to end the string. Now the whole program except that " has been pushed to the stack, with !dlroW ,olleH on top. Then it prints the top 12 characters the same way yours does and stops at @. – undergroundmonorail – 2015-09-28T17:40:30.267

Didn't though of the wrapping around. Great little hack ! – Luke Marlin – 2015-09-29T06:41:23.140

1

For the 18 byte solution, my interpreter produces Hello, World (leading space, no exclamation). The Anarchy Golf interpreter (use form, select Befunge-98, paste code, submit) does the same.

– primo – 2015-09-29T12:14:19.517

@primo Weird. It looks like k is executing , 12 times but it's not being executed again when the instruction pointer actually reaches it. Luckily it's an easy fix. – undergroundmonorail – 2015-09-29T12:24:38.200

@Luke The second character should be d, not c. I don't know why but it fixes the bug primo pointed out. – undergroundmonorail – 2015-09-29T12:24:51.923

@undergroundmonorail I don't think that's what's happening. According to the docs any out-of-bounds character defaults to 32. Because one is encountered, as part of a string, it gets pushed to the stack. One could argue that this is a bug, but it seems to be a common one.

– primo – 2015-09-29T12:32:35.860

@undergroundmonorail rcfunge gives the correct result with this exact code, and ck, do it 13 times as per the specification – Luke Marlin – 2015-09-29T13:51:07.453

In your explanation, you have a typo. Hello , World!@,kc There's an extra space. I haven't edited because that would be a trivial edit, and I don't have enough rep to do it w/o the review queue. – wizzwizz4 – 2015-12-25T10:10:05.877

28

Pada, 83 68 bytes

~.O~Ow~q~Owo~O~Oww~Q~qwo~q~O~wQ~q~w~q~q~Q~Ow~Q~Q~wo~q~w.~q~w.~.wO~qw

I believe this is optimal for a linear program (i.e. one which doesn't use the control flow operators ? and *). It might be optimal overall, but I don't know how to go about making use of those additional operators in such a small amount of code (or how to explore the possibilities programmatically).

The language has recently undergone some changes after I started discussing it with the author by email. However, I have written a reference implementation for the current state of the language spec last week, so the above code is actually runnable.

Metagolf

Originally, I had used the output of my reference implementation to this challenge and created a hand-crafted solution based on that. However, that was just a heuristic approach.

So instead I wrote a solver in Mathematica which actually knows about the Pada data structures and operators to find an optimal solution. On average, it grows linearly with the length of the string (although some character combinations are a bit slower than others) and took about 1.5 hours for Hello, World!.

So how did I go about writing the solver. First, we notice that we only need to consider 6 operators: ~.oOqQ (plus the necessary w for each of the printed characters). Using the stacks or the bit locks isn't useful in linear code, and I don't believe that ? and * can be used effectively in less than 68 bytes.

Pada's state (ignoring the stacks and locks) consists of 7 switches and 8 bits, arranged like this:

       /
   /       \
 /   \   /   /
0 1 0 0 1 0 0 0

So that's 215 = 32768 possible states. My first preprocessing step was to set up a directed graph of states where each edge corresponds to a single operation. That is, the graph has 32768 vertices, each with out-degree 6 (one outgoing edge for each of the 6 operations under consideration). We can use this graph to find the shortest path between any two states (this graph alone can be quite useful for golfing Pada).

Now for each character, we want to reach a state where w prints that character. How many such states are there? w reads the byte from the bit it is dropped on (cyclically). So there are 8 possible rotations of the bits of the character which can all print that character. For each of those rotations, three switches are fixed (in order to make w drop in the correct position). This leaves 4 arbitrary switches. So we've got 8 * 24 = 128 possible states for each w in our code.

With those we can solve another graph problem: construct a graph which has a source vertex, then one "layer" for each character, and a sink vertex. The layers consist of the 128 states for each vertex, the source node corresponds to the initial state of the program (all switches to the left and all bits are zero). The sink node corresponds to no state in particular. We've got directed edges from every vertex in one layer to every vertex in the next layer, where the edge weight is the distance between the two states in our earlier graph. The weights of the edges from the last layer to the sink are all 0. That is, we can precompute all those edge weights. This is the most expensive step of the computation and took 1.5 hours for Hello, World!.

With this graph set up, we can find the shortest path from the source to the sink quite quickly (it took 0.05s on my machine). For Hello, World! the desired states are:

0, 16960, 22052, 13828, 13828, 30389, 12487, 8307, 27299, 23450, 18922, 22778, 18682, 18459

where the least significant 7 bits correspond to the switches and the most significant 8 bits to Pada's bits.

Now we go back to the first graph and find the actual edges (i.e. operations) corresponding to the shortest path between each pair of subsequent states, and end each of them with a w. Voilà, an optimal solution (based on the above assumptions).

Here is the full Mathematica if anyone ever wants to metagolf a different string in Pada:

string = "Hello, World!";
width = StringLength@string;
getState[letter_, state_] := (
  {shift, switchState} = IntegerDigits[state - 1, 16, 2];
  bits = RotateRight[
    IntegerDigits[ToCharacterCode[letter][[1]], 2, 8], shift];
  switchState = IntegerDigits[switchState, 2, 4];
  switches = {-1, -1, -1, -1, -1, -1, -1};
  {top, middle, bottom} = IntegerDigits[shift, 2, 3];
  switches[[1]] = top;
  If[top < 1,
   switches[[2]] = middle;
   If[middle < 1,
    switches[[4]] = bottom,
    switches[[5]] = bottom
    ],
   switches[[3]] = middle;
   If[middle < 1,
    switches[[6]] = bottom,
    switches[[7]] = bottom
    ]
   ];
  For[i = 1, i <= 7, ++i,
   If[switches[[i]] < 0,
    switches[[i]] = First@switchState;
    switchState = Rest@switchState
    ]
   ];
  {bits, switches}
  )
encode[state_] := FromDigits[Join @@ state, 2]
decode[id_] := Partition[IntegerDigits[id, 2, 15], 8, 8, 1, {}]
getBitFromSwitches[switches_] := (
  If[switches[[1]] < 1,
   If[switches[[2]] < 1,
    1 + switches[[4]],
    3 + switches[[5]]
    ],
   If[switches[[3]] < 1,
    5 + switches[[6]],
    7 + switches[[7]]
    ]
   ]
  )
toggle[list_, index_] := ReplacePart[list, index -> 1 - list[[index]]]
stateEdges = Flatten@Table[
    {bits, switches} = decode@id;
    bit = getBitFromSwitches@switches;
    {
     Labeled[id \[DirectedEdge] encode@{bits~toggle~bit, switches}, 
      "~"],
     Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~1}, "."],
     If[switches[[1]] < 1,
      {
       Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~2}, 
        "o"],
       Labeled[
        id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~3}, 
        "q"],
       If[switches[[2]] < 1,
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~4}, 
         "O"],
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~5}, 
         "O"]
        ],
       If[switches[[3]] < 1,
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~3~toggle~7}, "Q"],
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~3~toggle~6}, "Q"]
        ]
       },
      {
       Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~3}, 
        "o"],
       Labeled[
        id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~2}, 
        "q"],
       If[switches[[3]] < 1,
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~6}, 
         "O"],
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~7}, 
         "O"]
        ],
       If[switches[[2]] < 1,
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~2~toggle~5}, "Q"],
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~2~toggle~4}, "Q"]
        ]
       }
      ]
     }
    ,
    {id, 0, 2^15 - 1}];
stateGraph = 
  Graph[# & @@@ stateEdges, EdgeLabels -> Rule @@@ stateEdges];
uid = 0;
layers = Join[{{{uid++, 0}}}, 
   Table[{uid++, encode@getState[#, i]}, {i, 128}] & /@ 
    Characters@string, {{{uid++, -1}}}];
edges = Flatten[Table[
      from \[DirectedEdge] to
      ,
      {from, #},
      {to, #2}
      ] & @@@ Partition[layers, 2, 1], 2];
Timing[weights = (
     {from, to} = Last /@ List @@ #;
     If[to < 0,
      0,
      GraphDistance[stateGraph, from, to]
      ]
     ) & /@ edges;]
characterGraph = Graph[edges, EdgeWeight -> weights];
Timing[path = 
  Last /@ Most@
    FindShortestPath[characterGraph, {0, 0}, layers[[-1]][[1]]]]
(PropertyValue[{stateGraph, #}, EdgeLabels] & /@ 
      DirectedEdge @@@ 
       Partition[FindShortestPath[stateGraph, ##], 2, 1] <> "w" & @@@ 
   Partition[path, 2, 1]) <> ""

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

An interesting language to do metagolf on =). This makes me wonder, what's your day job? o.O – justhalf – 2015-08-29T15:08:57.547

4

@justhalf I'm currently in limbo between a master's degree and PhD studies (so I've definitely got too much time on my hands if that was your implication ;)). (This is generally more of a discussion for chat though :))

– Martin Ender – 2015-08-29T16:00:12.773

Pada means when in bahasa Indonesia/Malay. Is that relevant? – XiKuuKy – 2016-10-28T15:28:23.137

@XiKuuKy afaik, the language is called Pada, because it means "falling" in Croatian. – Martin Ender – 2016-10-28T19:41:55.167

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

– Vitaliy Kaurov – 2017-09-20T15:30:58.183

27

C, 30 Bytes

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

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

LambdaBeta

Posted 2015-08-28T12:23:59.027

Reputation: 791

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

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

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

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

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

27

Brainfuck, 92 (hirose)

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

This is a slight modification of hirose's 92-byte solution for the lowercase-w version of the problem on Anarchy Golf.

Changing ++ to -- conveniently subtracts 32 from the cell that holds w, turning it into W.

Brainfuck, 95

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

For this solution, I used code that I wrote for this problem on SPOJ and touched up the output a bit by hand.

Note: Both solutions are compatible with Alex Pankratov's bff (brainfuck interpreter used on SPOJ and ideone) and Thomas Cort's BFI (used on Anarchy Golf).

Mitch Schwartz

Posted 2015-08-28T12:23:59.027

Reputation: 3 784

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

– JNV – 2015-08-30T08:41:11.580

What is the advantage of the 95-byte solution? Why mention it at all? – anatolyg – 2015-08-31T14:29:52.880

2

@anatolyg The 92 is my modification of hirose's solution. The 95 is another solution that I developed from scratch. If you can't see the value of mentioning alternative approaches, or of distinguishing your own work from (trivial or non-trivial) modifications of someone else's code, I don't know what to say. This type of thing is standard practice on Anarchy Golf, and I'd be happy to see it catch on here as well. Incidentally, I've been informed that the 95 translates to 97 in ???, while the 92 translates to 98.

– Mitch Schwartz – 2015-08-31T16:04:57.097

(I was misinformed; it's 95 -> 96 and 92 -> 97 for ???.) – Mitch Schwartz – 2015-08-31T20:29:06.737

25

JSFuck, 6293 6289 6277 bytes

This may get a mention as one of the longest "shortest Hello, World! programs" (actually I do not know if this is optimal, but it's the shortest I managed to get).

Warning: only works in Firefox and Safari

[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]](([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))()

There is also a slightly longer version (+4 bytes) that also works in Chrome and Microsoft Edge:

[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]]((![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))()

For those unfamiliar with JSFuck, it's about writing JavaScript as if there were only six characters, and it can get pretty crazy at times.

This table shows how the characters used in the Hello, World! program are encoded in JSFuck. The plain text code is just alert("Hello, World!").

+----------+--------------------------------------+---------------------------+
|JavaScript|               write as               |           JSFuck          |
+----------+--------------------------------------+---------------------------+
|     a    | (false+[])[1]                        | (![]+[])[+!![]]           |
|     l    | (false+[])[2]                        | (![]+[])[!![]+!![]]       |
|     e    | (true+[])[3]                         | (!![]+[])[!![]+!![]+!![]] |
|     r    | (true+[])[1]                         | (!![]+[])[+!![]]          |
|     t    | (true+[])[0]                         | (!![]+[])[+[]]            |
|     (    | ([]+[]["fill"])[13]                  | 114 bytes                 |
|     "    | ([]+[])["fontcolor"]()[12]           | 539 bytes                 |
|     H    | btoa(true)[1]                        | 1187 bytes                |
|     o    | (true+[]["fill"])[10]                | 105 bytes                 |
|   space  | ([]["fill"]+[])[20]                  | 107 bytes                 |
|     W    | (NaN+self())[11]                     | 968 bytes                 |
|     d    | (undefined+[])[2]                    | ([][[]]+[])[!![]+!![]]    |
|     !    | atob((Infinity+[])[0]+false)[0]      | 1255 bytes                |
|     )    | (0+[false]+[]["fill"])[20]           | 114 bytes                 |
+----------+--------------------------------------+---------------------------+

Here the strings "fill", "fontcolor", etc. must be written as "f"+"i"+"l"+"l", "f"+"o"+"n"+"t"+"c"+"o"+"l"+"o"+"r" to be encoded.

The global identifiers self, atob and btoa get written like Function("return self")().

Function itself should be []["fill"]["constructor"].

The comma "," is tricky, I'm not 100% sure how it works but it uses the []["concat"] function to create an array. I'll post an update when I have time to do more tests.


I encoded this using JScrewIt - credits to GOTO 0 for creating such a sophisticated tool:

  • Open Firefox (You can choose any other browser(s), but Firefox only code is the shortest.)
  • Navigate to JScrewIt: http://jscrew.it
  • Input: alert("Hello, World!")
  • Executable code: checked
  • Compatibility: Only this browser

This differs from my answer to this question for the presence of the comma after "Hello".

Interestingly, the ES6 syntax

alert`Hello, World!`

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

me and my cat

Posted 2015-08-28T12:23:59.027

Reputation: 792

Well it works in Chrome on Android – Beta Decay – 2015-08-30T08:25:57.823

Works in Chrome on OS X too – C0deH4cker – 2015-09-03T19:49:47.867

@BetaDecay @C0deH4cker I think that's because of the []["fill"]. Just updated my answer, thanks! – me and my cat – 2015-09-04T07:58:41.587

@Sp3000 Nice!!! Thanks ;) You could report that to JScrewIt as an issue. – me and my cat – 2015-09-06T12:45:58.207

Safari on OS X works too :D – Kametrixom – 2015-09-06T14:29:56.000

1You did a great job here! Be sure to check the last update. – GOTO 0 – 2015-09-07T23:22:37.517

4@GOTO0 Wait... you are the author of JScrewIt, right? – me and my cat – 2015-09-08T05:07:38.457

1How the hell do you call functions with this? – Midnightas – 2017-02-06T10:59:35.100

24

Unreadable, 843 755 732 666 645 629 577 bytes

'"'""'""'""'"'"'""""""'""'"""'""'""'""'""'""'""'""'"'""'""""""'""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'""""""""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""""""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"""'"'"""""""'""""""""'"""'"'"""""""'"""'"'"""""""'""'""'"""'"'""'""'""'"'""'""'""'"""""""'""'"""'"'"""""""'""'"""'"'"""""""'""'""'""'"""'"'""'"""""""'"""

Unreadable programs are supposed to be displayed with a variable-width font, so they honor the language's name. I'm slightly disappointed that my more sophisticated approaches turned out to be a lot longer. Loops are insanely expensive in Unreadable...

Try it online!

How it works

Unreadable has only ten functions; six of these are used in this code:

'"        p Print.
'""       + Increment.
'"""      1 Return 1.
'""""""   : Set.
'"""""""  = Get.
'"""""""" - Decrement.

After using my single-character notation and adding some whitespace and comments, the above code looks like the following. Multi-line statements are executed from bottom to top.

p+++                                        Print 3 + variable 2 (o).
 pp                                         Print variable 2 two times (l).
  :+1+++++++                                Save 8 + variable 3 in variable 2.
   p+                                       Print 1 + variable 3 (e).
    :++1+++++++++++++                       Save 13 + variable 4 in variable 3.
     :+++1+++++++++++++++                   Save 43 + variable 0 in variable 4.
      p++++++++++++++++++++++++++++         Print 28 + variable 0 (H).
       :-1++++++++++++                      Save 44 in variable 0.
        :1+++++++++++++++++++++++++++++++1  Save 32 in variable 1.
p=-1                                        Print variable 0 (,).
p=1                                         Print variable 1 ( ).
p=+++1                                      Print variable 4 (W).
p+++                                        Print 6 + variable 2 (r).
 p+++=+1                                    Print 3 + variable 2 (o).
p=+1                                        Print variable 2 (l).
p=++1                                       Print variable 3 (d).
p+=1                                        Print 1 + variable 1 (!).

I've generated the actual source code by running the uncommented version of the above pseudocode through this CJam program.

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

3What are you talking about? Its pretty readable! – Optimizer – 2015-09-03T19:03:01.273

17@Optimizer Fixed. – Dennis – 2015-09-03T19:06:45.300

4Still readable! (of course I am telling the truth. Why won't you believe me?) – Optimizer – 2015-09-03T19:10:43.030

5Feels like this language would benefit from a better huffman coding - both in terms of size, and unreadability. – primo – 2015-09-29T09:05:47.573

23

Pyth, 14 bytes

"Hello, World!

Doubt it'll get smaller than this in Pyth.

orlp

Posted 2015-08-28T12:23:59.027

Reputation: 29 965

12This also works in TI Basic – Patrick Roberts – 2015-09-08T19:40:18.313

I checked all nine zlib.compress levels with [len(zlib.compress("Hello, World!",i))+2 for i in range(10)] .Z"compressed text isn't more efficient for any level. – Tornado547 – 2017-11-28T16:51:28.930

21

Python 2, 20 bytes

print"Hello, World!"

Python 2 is better for printing than 3 :D

Beta Decay

Posted 2015-08-28T12:23:59.027

Reputation: 11 590

20Just in case anybody is wondering: import __hello__ prints "Hello world!", which is incorrect punctuation for this challenge. – Sp3000 – 2015-08-28T15:11:29.577

6

@Sp3000 Yeah, I looked into it. It actually prints Hello world... (tested on repl.it. You're thinking of Python 3, which has a different result.

– mbomb007 – 2015-08-28T15:13:51.863

@mbomb007 Ah, I didn't realise Python 2 and Python 3 had different __hello__ messages, indeed I tested on the wrong one. – Sp3000 – 2015-08-28T15:18:09.363

Python 2.7 prints Hello world... \o/ What is this!!! – Zizouz212 – 2016-09-16T01:37:57.090

19

Javascript (ES6), 20 bytes

alert`Hello, World!`

Javascript ES6 features are awesome when it comes to code golf!

Here, the use of templates allows for a two byte savings by removing parentheses.

How it works

This syntax is known as tagged templates, and it is not the same as merely calling a function with a single string as a parameter, as I initially thought. The function, in this case alert, is called with an array of the string portions of the template and an array of the inserted values. Since there were no inserted values and only a single string portion of the template, alert is called with the array ["Hello, World!"] as its sole (defined) parameter. alert displays this, conveniently, as Hello, World!

Try replacing alert with console.log, and it won't work! You'll get Array [ "Hello, World!" ] instead, since the console doesn't follow the same display rules as alert.

jrich

Posted 2015-08-28T12:23:59.027

Reputation: 3 322

wait, but alert does not print to STDOUT? – James_Parsons – 2015-08-30T23:38:53.820

4@James_Parsons Since JavaScript doesn't really have a traditional STDOUT, alert is typically considered acceptable. – jrich – 2015-08-30T23:41:31.307

oh, ok sorry. I'm kinda new here – James_Parsons – 2015-08-30T23:49:22.793

1@James_Parsons No problem. Welcome to PPCG! – jrich – 2015-08-30T23:50:18.403

6console.log("Hello, World!") (28 bytes) outputs to STDOUT if run in node. – jib – 2015-09-05T19:20:39.453

3

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

– tsh – 2015-09-08T06:27:45.033

19

Java 8, 76 bytes

Thought I would try to beat Geobit's answer :)

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

Try here!

TheNumberOne

Posted 2015-08-28T12:23:59.027

Reputation: 9 230

18

Stack Cats, 134 + 3 = 137 148 907 bytes

I'm happy to give a 500-rep bounty to the first person who can bring this down below 100 (+3) bytes.

-*(:^-_-_:-_:-_:-_:-_-_:[:^]]:^!-*!->[!_>[!_>[{]>[^-_-_:]]<<<}>[!-:^[[\\>]:^[[>:[>:^[<<]]\\>[*>+:^:-_]:^[[-_*[>>>[-_[/<]>+^[>[<<]]*>[)

Needs to be run with the -l switch of the Ruby interpreter, hence +3 bytes.

Try it online!

There's definitely still room for improvement here, but I haven't quite figured out myself yet how to program in this language effectively. The current solution was just a general idea for how to approach the challenge and I just wrote the code in a rather ad-hoc way. Even without changing the overall approach I'm confident that one can end up much closer to 100 bytes or even below.

Explanation

Proudly introducing my latest creation, this time in collaboration with Sp3000. :) The idea for this language was originally born for feersum's language design CnR, but at the time we weren't able to figure out whether this idea was usable, and then kept putting it off. A couple of weeks ago we decided to revisit the idea, cleaned up the design a lot and managed to make progress towards proving its Turing-completeness, so here it is.

Stack Cats is a stack-based, reversible programming language. In fact, in order to undo any piece of code, you simply mirror it (which means reversing it and swapping all brackets and slashes). Furthermore, every program has to have mirror symmetry itself. This implies that every non-trivial program has odd length and the form f g f-1, where g is a single very simple command which is also an involution. That makes programming and especially golfing in Stack Cats fairly tricky.

Note that the source code above isn't actually symmetric. This is because the -l switch lets you omit the first half (before the g), since it's redundant in any valid program anyway. So the full program is actually:

(]<*[[>>]<]^+<[>\]_-]<<<]*_-]]^:[_-:^:+<*]<//[[>>]^:<]:<]]^:[<//]]^:-!]<{>>>[[:_-_-^]<[}]<_!]<_!]<-!*-!^:[[^:]:_-_-:_-:_-:_-:_-_-^:)*-*(:^-_-_:-_:-_:-_:-_-_:[:^]]:^!-*!->[!_>[!_>[{]>[^-_-_:]]<<<}>[!-:^[[\\>]:^[[>:[>:^[<<]]\\>[*>+:^:-_]:^[[-_*[>>>[-_[/<]>+^[>[<<]]*>[)

When I say "stack-based", I mean that the memory model is actually a tape of stacks. As in my other stack-based languages, each stack is initially implicitly filled an infinite amount of zero (this time, that was actually necessary to ensure full reversibility of all commands on all possible states). In addition to this the initial stack starts with a -1 on top when there is no input (which is the case here).

Output in Stack Cats works simply by printing the contents of the final stack, top to bottom. So the goal is to generate a stack with the following values (top is right):

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

(There are a few other options but this is what the above program does.)

I'm going to represent the tape as follows, with the v indicating the tape head's position:

     v
... -1 ...
     0

Now on to the code. Note that the program begins with a (...) which continues until just before the central *-*. This is a loop, which can be used as a conditional. The loop is entered and exited only when the top of the stack is positive. Since the initial stack holds a -1, the entire first half of the program is skipped. This makes programming a lot easier, but of course it's also somewhat wasteful in terms of golfing. I haven't yet been able to figure out how to make easy use of both halves of the code except for simple toy problems.

Next comes the *-*. Here, * takes the top of the stack XOR 1, i.e. turns -1 into -2, the - negates it to give 2 and then we have another *, giving 3. Now that the top of the stack is positive, we do enter the (...) in the second half. The code in there will be executed only once and now turns this single 3 into the stack we need for the output.

It turns out that the quickest way to obtain large numbers without loops is a Fibonacci-like progression where we repeatedly add the last value to the one before. I say Fibonacci-like because we have some flexibility here since we can occasionally increment or decrement values in the process, or add the last value to the previous one several times before swapping their roles.

For now, we're trying to compute 33 and 87, because they both appear in the same Fibonacci-like sequence. (And they are the character codes of ! and W.) If the top of the stack is a and the value below is b, I'll be writing this as (a, b), so the current state is (3, 0). Let's go:

:    Swap the top two values.              (  0,  3)
^    XOR the second into the first.        (  3,  3)
-    Negate top.                           ( -3,  3)
_    Subtract top from second.             (  6,  3)
     As you can see, -_ can be used to
     add the second-to-top to the top.
-_   Add second into top.                  (  9,  3)
:    Swap.                                 (  3,  9)
-_   Add second into top.                  ( 12,  9) 
     The last two together form a normal
     "Fibonacci step".
:-_  Fibonacci step.                       ( 21, 12)
:-_  Fibonacci step.                       ( 33, 21)
:-_  Fibonacci step.                       ( 54, 33)
-_   Add second into top.                  ( 87, 33)
:    Swap.                                 ( 33, 87)

Now [ pushes the 33 one stack to the left (moving the tape head along), :^ duplicates it and ] moves one copy back. Together, this just puts a 33 on the stack to the left. And then ]:^ moves the 33 to the right and duplicates it again there. So now we've got:

           v
          33    
... 33 87 33 ...
     0  0  0

Next, it turns out that most of the lower case letters are multiples of 3 and their other factors are 36, 37, 38 which aren't too far away. 99 is also useful, since we'll need both 100 and 101, so we now create a stack with those factors so we can multiply all of them by 3 later.

Stack Cats doesn't have a decrement or increment command. The standard way to increment a value is to combine bitwise NOT (!) and unary negation (-). However, if we know that our value is even we can also increment by toggling the least significant bit with *. Hence, the following !-*!- brings the 33 on top of the stack up to 36. Next, we pull over two 0s from the empty stack to the right, turn use them to get incremented copies of the 36 with >[!_>[!_. The tape now looks like this:

           v
          38    
          37    
          36    
... 33 87 33 ...
     0  0  0

Time for the loop:

>[{]>[^-_-_:]]<<<}

Besides the (...) we've already seen, Stack Cats has another loop, {...}, but its semantics are also a bit unusual. The loop body is always executed at least once. When the loop starts, Stack Cats remembers the value on top of the stack, and then the loop doesn't terminate until that value is seen again at the end of an iteration. That means the easiest way to work through a stack is to put a zero on top and then shift the stack away one value at a time until we hit the zero at the bottom. Here is what the loop does:

>[       Fetch a zero from the empty stack to the right.
{        Loop until zero...
  ]        Push the current factor X to the right.
  >[       Fetch a zero from the stack next to that.
  ^        XOR X into that zero, duplicating X.
  -_-_     Add X into the new value twice, computing 3*X.
  :        Swap 3*X and X.
  ]]<<     Push X two stack to the right and return.
  <        Move back to the stack we're looping over.
}
>        Move onto the stack which now holds the multiples.

This is the new tape:

              v
             99   33    
            108   36    
            111   37    
... 33 87   114   38 ...
     0  0 0   0 0  0

The next bit is [!-:^ which you've seen before: it increments the 99 to 100 and duplicates it on the empty stack next to it. The [[ moves one of those 100s over onto the 33 — we're now starting to build the final stack there. Here's what we've got:

      v
                     33    
               108   36    
    100        111   37    
...  33 87 100 114   38 ...
      0  0   0   0 0  0

It's going to be annoying to fetch all the values from so many stacks away, so here's a new command. \ swaps the current stack with the one of the right, moving the tape head along. So the \\ now brings the output stack closer to the useful values:

             v
                     33    
               108   36    
           100 111   37    
... 87 100  33 114   38 ...
     0   0   0   0 0  0

Next, there's >]:^ which moves the 108 onto the empty stack to duplicate it. [[>:[ moves one of them and the 114 onto the output stack. >:^[ duplicates the 111 and moves one copy onto the output stack. Then we fetch the 87 with <<]], and move the stack two positions further with another \\. We've now got World!:

                  v
                 87       
                111       
                114 33    
                108 36    
                100 37    
... 100 111 108  33 38 ...
      0   0   0   0  0

Time for the space: we've still got that 33 around, so we fetch and decrement it with >[*. We don't need those 36, 37, 38 any more, but we do need a 44. We also still need the 72 for the H later on, and we can actually compute that on the way. All of this is accomplished with the following code:

>+:^:-_]:^[[-_*[>>>[-_[

The new command here is + which swaps the top of the stack with the third value from the top. We use it together with : to put the 36 below the 37 and 38. The ^ replaces the 37 with 37 XOR 38 which is 3. We then add this to 38 with :-_ which gives 41. ]:^ duplicates that on the stack to the right. Then we add a 32 into it with [[-_ and decrement it with * by toggling the least-significant bit. Voilà, there's our 72. We move it to the side with [, go back to the other copy of 41 with >>> and add another 3 into it with [-_ before putting it on the output stack with [. Next, we move the current stack to the left with /. Here's the current tape:

              v
             44           
             32           
             87           
            111           
            114           
            108           
            100  72  3    
... 100 111  33 108 36 ...
      0   0   0   0  0

Now all that's left is collecting a few more values with

<]>+^[>[<<]]*>[

The <] fetches the 111. Then >+^ swaps the 72 with the zero below in order to duplicate the 108. [>[ moves both of those onto the output stack. <<]] fetches the 100 and * turns it into a 101. Finally >[ gets the 72 and we're done.

If you've actually followed all of this you'll noticed that there's tons of stuff we could have done differently which may or may not have saved bytes. There are many more ways to compute the different numbers, maybe XOR would have been useful more often. We could also generate some larger or negative numbers, since the final values are taken modulo 256 before being printed. We could also have made more use of loops, or used the stacks differently. There are also further stack manipulation commands like | to reverse it, X to swap the stacks left and right and = to swap only their top values.

As difficult as it is to program in Stack Cats, it still provides quite a large set of useful commands, which allow for many different approaches to any given problem.

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

17

Common Intermediate Language, 126 123 bytes

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

With proper indentation:

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

ProgramFOX

Posted 2015-08-28T12:23:59.027

Reputation: 6 554

17

Jelly, 8 bytes

“3ḅaė;œ»

Try it online!

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

Wat. How on earth did you compress it so much... – ETHproductions – 2016-01-11T15:42:34.120

4Jelly now has an experimental decompressor that indexes an English dictionary. – Dennis – 2016-01-11T16:00:39.227

12Jelly is ḅaė. – mbomb007 – 2016-02-24T19:54:52.223

2you mean: ḅaė is jelly – Daniele D – 2016-08-12T09:06:47.000

16

Wordy, 1666 bytes

xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx x x x x x x x.xxx xxx xxx x x.xx x.x x x x x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x.xx x.x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x.xx x.x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x.xx x.x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x x.xx x.x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x x x x x x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x x x x x.xx x.x x x x.xxx xxx xxx x x x x x x x.xxx x x.xxx xxx xxx x x x x.xxx xxx x x x.xxx xxx xxx x x.xx x.x x.xx x.x.

We can greet the World by executing the following instructions:

ASSIGN NOP LITERAL 16
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 4 LITERAL 8
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 5
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 12
OUTCHAR MULTIPLY VALUE NOP LITERAL 2
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 5 LITERAL 7
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 7 LITERAL 2
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 4
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 1

Wordy encodes all instructions as sentences, where the fraction of words that are longer and shorter than the rounded average selects the command.

The shortest sentences I could find for the used instructions are:

ASSIGN xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx x x x x x x x.
VALUE xxx xxx x x x.
ADD xxx x x.
MULTIPLY xxx xxx xxx x x x x.
OUTCHAR xxx xxx xxx x x x x x x x.
NOP xxx xxx xxx x x.
LITERAL xx x.

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

16

Piet, 93 codels

The 1 pixel bitmap of the 31x3 program :

Piet 31x3 - Codel 1[1]

There might be still some room for improvement.
But the Direction Pointer & Codel Chooser are not making things easier.

This is the 12 codel image :

Piet 31x3 - Codel 12[2]

Remarks :

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

LukStorms

Posted 2015-08-28T12:23:59.027

Reputation: 1 686

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

1Yes, I noticed that after I posted this solution. The div problem on PietDev is not a problem if you just use it for output, since that only uses the integer part. And i.m.h.o., I do believe it would be an enrichment to npiet if it allowed to start with black codels till another colour is found. You could write piet programs with a black frame that way. – LukStorms – 2015-09-09T07:45:29.163

I'm awarding the bounty to this submission, despite the black codel. The reuse of 2 and 3-large cells is very nice - I thought I'd try golfing this down a column or two but it's surprisingly hard. Makes me think 87 might be possible though. – Sp3000 – 2015-09-09T07:56:38.000

@Sp3000 Thanks for the bounty reward. I've been trying to find a solution without the black codel that's below 30x3. But can't seem to find one. But I still believe there should exist a 29x3 solution. Piet is just a immense pain to golf. It's not just a matter of getting the optimal result from the stack. – LukStorms – 2015-09-14T21:24:52.270

15

Java, 61 bytes

enum H{H;{System.out.print("Hello, World!");System.exit(0);}}

This is valid in both Java 5 and Java 6. This won't work in Java 4 or earlier (because enum didn't exist) and will not work in Java 7 or after (because the bypass[1] was "fixed").

enum H {                               // An enum is basically a class.
  H;                                   // Static initialization of the mandatory instance, invoking the default constructor.
                                       // Happens before the existence check of "main"-method.
                                       // No constructor means default constructor in Java.
  {                                    // Instance initialization block.
                                       // Executed in each constructor call.
    System.out.print("Hello, World!"); // duh!
    System.exit(0);                    // Exit before the JVM complains that no main method is found.
                                       // (and before it writes on stderr)
  }
}

Rough equivalence in Java as usually written

The above code is roughly equivalent to the following one.

class HelloWorld {
  public final static HelloWorld INSTANCE;
  static {
    INSTANCE = new HelloWorld();
  }
  public HelloWorld() {
    System.out.print("Hello, World!");
    System.exit(0);
  }
}

Proof of correctness

$ java -version
java version "1.6.0_45"
Java(TM) SE Runtime Environment (build 1.6.0_45-b06)
Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode)

$ javac H.java

$ java H
Hello, World!
$

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

Olivier Grégoire

Posted 2015-08-28T12:23:59.027

Reputation: 5 391

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. – Steven Vascellaro – 2017-09-20T13:45:40.687

@StevenVascellaro Explanations have been added. – Olivier Grégoire – 2017-09-20T13:57:12.680

5The explanation is much appreciated. I still recommend specifying the language as Java 6 in the title to distinguish it as a unique, version specific language – Steven Vascellaro – 2017-09-20T14:09:14.407

@StevenVascellaro "This is not about finding the language with the shortest "Hello, World!" program. This is about finding the shortest "Hello, World!" program in every language." This is the shortest answer in Java (so far); not writing the version is actually more correct as answer. Plus you're aware of the Java 8 answer, but haven't asked that answer to be Java 8 tagged. Double standard?

– Olivier Grégoire – 2017-09-20T14:15:09.173

1@OlivierGrégoire Nice job ;) Also, I changed my program's header to Java 8 when I saw the comments here. – TheNumberOne – 2017-10-09T22:56:40.103

Uh, this is actually 61 bytes

– caird coinheringaahing – 2017-11-25T19:51:13.423

@cairdcoinheringaahing Oops, thank you, I fixed it. – Olivier Grégoire – 2017-11-27T14:03:15.570

Isn't stderr ignored on PPCG? Wouldn't that mean that you can remove the System.exit? – NieDzejkob – 2018-03-10T15:53:42.257

@NieDzejkob The challenge explicitly says no to that interpretation. – Olivier Grégoire – 2018-03-10T17:58:45.290

14

Starry, 191 188 186 182 172 169 bytes

        + + +* +  * + + +* + .* +         + +* * +      +* .  + + . + . +        + +   +* + . +          +   * +* + .         + +  * +* . +*      + * . + .* . . .  + * .

This is almost definitely suboptimal, but Starry golfing is surprisingly difficult, due to the cost of pushing a number being higher than that of performing an operation. Thankfully we can reuse a lot of past computations, due to duplicate letters in the message "Hello, World!".

Starry operators are determined by the number of spaces before one of +*.,`. The relevant ones used are:

Spaces       Char      Operation
-----------------------------------------------------
1            +         Duplicate top of stack
2            +         Swap top 2 stack elements
3            +         Rotate top 3 stack elements
n >= 5       +         Push n-5 to stack
0 mod 5      *         Add
1 mod 5      *         Subtract
2 mod 5      *         Multiply
1 mod 2      .         Output as ASCII

And here is the program broken down:

Line                        Explanation            Stack                 Out
-------------------------------------------------------------------------------------
        + + +* +  * +       Push 3 and 36, dup     [3 36 36]
 + +* + .                   Dup, x2, dup, print    [3 36 36 72]            H
*                           Add                    [3 36 108]              H
 +         + +* * +         Dup, sub 8, dup        [3 36 108 100 100]      H
      +* .                  Add 1, print           [3 36 108 100]          He
  + + .                     Swap, dup, print       [3 36 100 108]          Hel
 + .                        Dup, print             [3 36 100 108]          Hell
 +        + +               Dup, push 3, dup       [3 36 100 108 108 3 3]  Hell
   +* + .                   Rot 3, add, dup, print [3 36 100 108 3 111]    Hello
 +          +   * +* + .    Dup, //5*2, dup, print [3 36 100 108 3 111 44] Hello,
         + +  * +* .        Print 32               [3 36 100 108 3 111 44] Hello, 
 +*      + * .              Double, sub 1, print   [3 36 100 108 3 111]    Hello, W
 + .                        Dup, print             [3 36 100 108 3 111]    Hello, Wo
* .                         Add, print             [3 36 100 108]          Hello, Wor
 . .                        Print, print           [3 36]                  Hello, World
  + * .                     Swap, sub, print       []                      Hello, World!

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

14

Cheddar, 20 bytes

print"Hello, World!"

Yes!!!!!

I have been waiting for this day a long time. After days of banging my head on my desk trying to get Cheddar to work. I have finally made a Cheddar REPL. The REPL is very alpha, so if you'd like to test it out, ping me in chat @Downgoat

Update: To run simply go to cheddar.vihan.org and follow the download instructions

Update 2: Use the experimental online REPL at: cheddar.vihan.org/repl

Downgoat

Posted 2015-08-28T12:23:59.027

Reputation: 20 837

2-1 Language name makes me want cheese ;) – Beta Decay – 2016-08-15T20:22:39.993

13

Python 3, 22 bytes

print("Hello, World!")

In Python 3, printing is a function and so it requires parenthesis.

A 16 byte solution would be import __hello__, but annoyingly this prints the message without the comma!

Blue

Posted 2015-08-28T12:23:59.027

Reputation: 22 461

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

13

GOTO++, 31 bytes

s=«Hello, World!»
GOTOPRINT()

This one is actually a bit interesting. There is a more intuitive way to output things in GOTO++, which would be this:

GOTOPRINTDUTEXTE()«Hello, World!»

This is however 35 bytes. GOTOPRINTDUTEXTE outputs its arguments to STDOUT (Du texte means some text in french). Note that the arguments of a function don't necessarily have to be inside the brackets, as long as they are to the right of the left bracket. So GOTOPRINTDUTEXTE()«Hello, World!» is just as valid as GOTOPRINTDUTEXTE(«Hello, World!»)

GOTOPRINT() on the other hand, outputs to STDOUT the very last variable modified by a =.

Fatalize

Posted 2015-08-28T12:23:59.027

Reputation: 24 736

13

><>, 23 bytes

"!dlroW ,olleH"l?!;oe0.

><>, or "Fish", is a 2D stack-based language like Befunge. Here's the breakdown:

[setup]

"                    Start string parsing
!dlroW ,olleH        Push each of these chars one-by-one onto the stack
"                    Stop string parsing

[main loop]

l?!;                 If the length of the stack is 0, halt
o                    Otherwise, output the top of the stack as char
e0.                  Jump back to just before the l

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

13

Piet, 15x15(225) 13x15(195) codels

I think Piet program size is counted by codels. If someone wants to know the size in bytes anyway, I could shrink it down to 495 bytes(15x15 codels) and 476 bytes(13x15 codels) using PNGGauntlet.

Codel size 10 for better visibility.

13x15 version:

Piet "Hello, World!" 13x15

First version (15x15):

Piet "Hello, World!"

I was a bit lazy with this solution. I should be able to golf it down a bit more. This solution fills up the stack with ASCII-32 and reads it out in a loop (ASCII+32).

Output:

D:\codegolf\Piet\npiet-1.3a-win32>npiet "Hello World codegolf.png"
Hello, World!
D:\codegolf\Piet\npiet-1.3a-win32>

M L

Posted 2015-08-28T12:23:59.027

Reputation: 2 445

13

FiM++, 88 bytes

Dear Princess Celestia:H.Today I learned:I sang "Hello, World!".Your faithful student,M.

FiM++ is an object-oriented language inspired by My Little Pony: Friendship is Magic. Yeah, right.

Printing "Hello, World!" is fairly straightforward, and there was an example in the interpreter's repository which I used as the basis for the above code. The main golfing steps were figuring out which parts could be shortened or left out and which couldn't... and the fact that I could replace I wrote ... with I sang ....

The interpreter prints a bunch of diagnostic information before running the code, but that does not appear to be part of the actual language specification.

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

13

Minecraft 1.8.7, 26 + 2 = 28 Blytes

This is using this version of byte counting.

the system

The command block contains the code:

tellraw @a "Hello, World!"

This one doesn't really need an explanation.

Addison Crump

Posted 2015-08-28T12:23:59.027

Reputation: 8 084

Use a button instead on this one. – SuperJedi224 – 2015-11-13T00:42:07.037

1This scoring method is called blytes (blocks + bytes). – user48538 – 2016-01-10T15:45:19.700

@zyabin101 I know - I created the term. I hadn't updated it though. :P Thanks. – Addison Crump – 2016-01-10T17:58:04.840

8You couldn't have taken a screenshot during the day? – mbomb007 – 2016-02-24T19:57:05.343

13

Wierd, 1341 bytes

Unlike other languages where the symbols in a program determine which instructions are executed, in Wierd, it is the bends in the chain of arbitrary symbols that determine which instructions are executed.

From the website:

First, a Riddle:
Q: What do you get when you put three marginally-sane programmers on a mailing list with the Befunge and BrainF*** programming languages?
A: You get BeF***, and then they get Wierd.
...
Chris Pressey then jumped on it, created the angle-to-instruction mapping, and christened the entire mess "Wierd"--a cross between the words "weird" (which the language seemed to be) and "wired" (which would describe the appearance of programs written in the language).

Try it online at http://catseye.tc/installation/Wierd_(John_Colagioia)

EDIT: Dennis has killed this answer quite thoroughly with this

Even though this is much smaller than the sameple that comes with the interpreter I am positive this can be golfed more (and it has been - by Dennis) Please try to come up with something smaller and edit the question with that version.

,!dlroW             ++
o     #           ++  +
l               ++    + ++++
l     +++     ++      ++  +
e    +   +  ++    ++  +  +
H   +  +  ++    ++  +   +
+  +  ++      ++     +++
+ ++++ +    ++
+      +  ++           ++
+  +++++++   +++     ++  +
 ++    +    +   +  ++    + ++++
       +   +  +  ++      ++  +
       +  +  ++      ++  +  +
       + ++++ +    ++  +   +
       +      +  ++     +++
       +  +++++++
        ++    +   +++
    +         +  +   +  ++
    ++       +  +  +  ++  +
    + +     +  +  ++      + ++++
    +  +    + ++++ +      ++  +
     +  +   +      +  ++  +  +
      +  +  +  +++++++  +   +
    ++++  +  ++    +     +++
    +      +       +
     +      +++++++      +++
      +                ++   +
       +             ++     +
       +           ++      +
++++++++++++     ++   ++  ++++
 +     +    +  ++   ++  +     +
  ++++ +     ++   ++     +++++++
    +  +        ++
   +   +      ++
  +    +    ++
 +     +  ++
+       ++        +++
+               ++   +
+ +++++++     ++     +
+  +     +  ++      +
+   ++++  ++   ++  ++++
+     +      ++  +     +
+    +     ++     +++++++
+    +   ++
+  ++++++   +++++++     +++
 ++  +       +     +  ++   +
     +        ++++  ++     +
     +          +         +
     +      ++++     ++  ++++
     +             ++  +     +
     +  +++++++++++     +++++++
      ++

Jerry Jeremiah

Posted 2015-08-28T12:23:59.027

Reputation: 1 107

1Nice job! I was hoping someone would beat the official HW example eventually. :) – Martin Ender – 2016-01-12T09:15:57.993

I wonder if they misspelled "weird" intentionally... – mbomb007 – 2016-02-24T19:58:22.800

1

@mbomb007 Yes. The web page http://catseye.tc/view/wierd/dialect/wierd-jnc/doc/wierdspec.txt says that Chris Pressey then jumped on it, created the angle-to-instruction mapping, and christened the entire mess "Wierd"--a cross between the words "weird" (which the language seemed to be) and "wired" (which would describe the appearance of programs written in the language)

– Jerry Jeremiah – 2016-02-24T20:12:29.817

12

Hot Soup Processor, 17 bytes

mes"Hello, World!

This one's pretty straightforward, but I'm not aware of any other language which can use mes ("message") to print. The language itself is actually of Japanese origin, as one can tell from their website.

Apparently the closing quote isn't necessary (as of ver 3.4a), which is unusual for a non-esolang.

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

4"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? – therealfarfetchd – 2017-01-29T21:15:07.190

12

Alchemy, 1013 bytes

Fixate 1 dr Eulerius (1 oz Alkahest): Bius
Fixate 1 dr Periphius (1 oz Alkahest): Cius
Fuse 1 dr Bius, 1 dr Bius, 1 dr Cius, 1 dr Cius (4 oz Alkahest): Zius
Fuse 1 dr Zius, 1 dr Bius (2 oz Alkahest): Hium
Fuse 1 dr Cius, 1 dr Periphius, 1 dr Periphius (3 oz Alkahest): Dius
Project 1 oz Hium, 1 oz Dius (3 oz Alkahest): Eium
Fuse 1 dr Zius, 1 dr Cius (2 oz Alkahest): Lium
Project 1 oz Lium, 1 dr Cius (3 oz Alkahest): Oium
Fuse 1 dr Bius, 1 dr Cius, 1 dr Eulerius, 1 dr Eulerius (4 oz Alkahest): Cium
Ferment 1 dr Zius, 1 dr Periphius (2 oz Alkahest): Sium
Project 1 dr Cium, 1 dr Cium (4 oz Alkahest): Wium
Ferment 1 dr Wium, 1 dr Aquaphidium (4 oz Alkahest): Wium
Project 1 dr Oium, 1 dr Cius (3 oz Alkahest): Rium
Ferment 1 dr Eium, 1 dr Aquasoothius (3 oz Alkahest): Dium
Project 1 dr Sium, 1 dr Aquasoothius (3 oz Alkahest): Xium
Multiply 1 oz Hium, 1 oz Eium, 1 oz Lium, 1 oz Lium, 1 oz Oium, 1 oz Cium, 1 oz Sium, 1 oz Wium, 1 oz Oium, 1 oz Rium, 1 oz Lium, 1 oz Dium, 1 oz Xium (26 oz Alkahest): Scribius

This is one weird language. The above is probably not entirely optimal, but I also don't think that the optimal solution will be significantly shorter (I did try to obtain the numbers as efficiently as possible locally). Also, the language spec seems to imply that the amounts of the reagents should actually match up (when multiplied by their "substance numbers" which are the sums of their ASCII values...), but the only interpreter I could find doesn't seem to be checking that.

In fact, the interpreter had a memory corruption bug which I had to fix to run the above code.

Some explanation would probably be helpful. Let e, π, and φ have their usual meanings. Then the above code translates roughly to the following pseudocode:

b = floor(e)         // 2
c = floor(π)         // 3
z = b * b * c * c    // 36
H = z * b            // 72
d = c * π * π        // 29.6088
E = H + d            // 101.6088
L = z * c            // 108
O = L + c            // 111
C = 2 * 3 * e * e    // 44.3343
S = z - π            // 32.8584
W = C + C            // 88.6686
W = W - φ            // 87.0506
R = O + c            // 114
D = E - 1            // 100
X = S + 1            // 33
Print( H, E, L, L, O, C, S, W, O, R, L, D, X )

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

12

IRC, 27 bytes

/nick h
/quit Hello, World!

The esolangs page comes with a really lengthy two-file "Hello, World!" example. It turns out that is completely unnecessary. The main file of an IRC program contains the program name, a list of channels (which are found in separate files and define individual threads) as well a generic error message which is displayed for various errors. However, that error message can be anything and goes to STDOUT. So let's define our error message as Hello, World!. The shortest way to raise an appropriate error is simply not to define any channels. Voilà, almost 800 bytes saved.

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

5You know some of the weirdest esolangs. – refi64 – 2015-09-03T23:47:58.723

Does it print to STDERR? – minmaxavg – 2016-07-01T00:02:39.140

1@minmaxavg it's been a while, but since I explicitly mention it in the explanation I'm pretty sure that I checked that the error message goes to STDOUT and not too STDERR. – Martin Ender – 2016-07-01T05:49:00.987

12

Cubix, 31 29 bytes

Saved 2 bytes thanks to @MartinBüttner

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

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

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

Explanation

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

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

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

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

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

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

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

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

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

ETHproductions

Posted 2015-08-28T12:23:59.027

Reputation: 42 391

11

Fission, 17 bytes

R"Hello, World!";

or

;"!dlroW, olleH"L

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

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

11

Sed, 14 bytes

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

cHello, World!

All that is required as input is one empty line.

Digital Trauma

Posted 2015-08-28T12:23:59.027

Reputation: 55 069

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

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

11

gs2, 2 bytes

\x12h

where \x12 is a raw byte.

Lynn

Posted 2015-08-28T12:23:59.027

Reputation: 41 980

11

GNU Make, 27

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

Digital Trauma

Posted 2015-08-28T12:23:59.027

Reputation: 55 069

You can stick these two lines together, in either order, on one line to eliminate one more char. – user3710044 – 2017-03-19T08:48:45.123

11

Funciton, 212 209 bytes

╔══════════╗
║2388215291╟
║3945970717║
║0943959830║
║0709090713║
║3592077341║
║6068961777║
║8210571695║
║52834632  ║
╚══════════╝

I found that 10 digits per row yielded the least bytes, although there may have been a mistake in my calculations.

LegionMammal978

Posted 2015-08-28T12:23:59.027

Reputation: 14 318

11

Brain-Flak, 148 + 3 = 151 bytes

Now that DJMcMayhem's answer has depreciated. I made a replacement (and even removed a few bytes).

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

Try it Online!

This requires the -A flag to run (-A forces ASCII output) adding 3 bytes to the total.

Explanation

This explanation was create by Poke

(
 (
  (
   (
    (
     (
      (
       (
        (
         (
          (()()()()){} Add 8... to 0
         ){} Double to 16
        ){}() Double and add 1 to 33 which is !
       ) Push the ! to save it for the end
      ) Push an extra 33 to help add to get to the first letter
     ){}{}() Triple the 33 and add 1 for 100 which is d
    )[][][][] Push the d to save it for the end. Add height-2, 4 times for 108 which is l
   )[][] Push the l to save for the end then add height-3, 2 times = 114 which is r
  )[[]]() Push the r to save for the end then subtract height-4 and add 1 = 111 which is o
 )[[][][][][]]() Push the o to save for the end then subtract height-5 5 times and add 1 = 87 which is W
) Push W to save for the end
At this point the stack contains "!dlroW". 87 Floating
( We're now a level lower so we start at 0 for the math here.
 [([]([])[][]{})]()()() Push 6+6+7+7+6=32 which is the space, then negate it + 3 = -29 Floating
 (
  [[]] negate height-7 = -7 Floating
  (
   (
    [()()()] -3 Floating
    (
     [([][][])] Push 3*height-7 = 21 and negate it = -21 Floating
     (
      (
       (
        ({}()){} 21+1+22 = 44 which is the comma
       ) Push the , to save for the end
      ) Push another 44
     ){}{} 44+44+44 = 132
    ) Push 132 plus the -21 we left floating earlier = 111 which is o
   ) Push 111 plus the -3 we left floating earlier = 108 which is l
  ) Push another l
 ) Push 111 plus the -7 we left floating earlier = 101 which is e
) Push 101 plus the -29 we left floating earlier = 72 which is H
At this point the stack contains "!dlroW ,olleH" and our accumulator is at 159 which doesn't get used.

Wheat Wizard

Posted 2015-08-28T12:23:59.027

Reputation: 33 549

4

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

– Poke – 2017-04-12T14:37:18.930

I'm curious, why does the -A flag cost 3 bytes? Most languages I've come across charge 1 or 2 bytes for a single flag. – Oliver – 2017-08-20T05:11:15.383

@Oliver Whether it costs one or three is a bit of a gray area. The sense behind 3 is that it costs the A the - and an additional space. However since A can be added on to other flags, for example -eA does both -e and -A, it only costs one byte if another flag is present. The rule is that you take the difference between your call and the "default call" for some languages the default already includes flags meaning they only pay one extra. However its not clear what Brain-Flak's default is so you will see different people score this in different ways. Flags are a real mess. – Wheat Wizard – 2017-08-20T05:14:50.003

I see. Thanks for the explanation! – Oliver – 2017-08-20T05:17:55.910

10

Packed 7-bit ASCII, 12

fÍëWßËfD 

Since Markdown eats some of the characters, here's a hexdump:

$ xxd hello.ascii 
0000000: 9197 66cd eb10 57df cb66 4420            ..f...W..fD 

And yes, the trailing space is necessary.

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

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

isaacg

Posted 2015-08-28T12:23:59.027

Reputation: 33 634

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

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

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

10

Labyrinth, 46 45 40 bytes

72.10:1.:8:..:):1:.#2#4..:1..4.:8.0.33.@

Try it online!

Labyrinth is my new two-dimensional programming language (although the 2D'ness isn't really used here). Labyrinth operates on two stacks (although this code only uses one). Each character is a separate command. However, as opposed to most similar languages individual digits don't push that digit (which makes it annoying to build up larger numbers), instead they multiply the top of the stack by 10 before adding themselves. This allows you simply to write out the numbers you want to push. (Another language with this concept is Emmental.)

The other commands you need to know for the above code are . which prints the top of the stack (modulo 256), : which duplicates the top of the stack, ) which increments it and # which pushes the current stack depth. @ terminates the program. There's only one tricky part: W is printed by appending a 1 to 111 (o), because 1111 % 256 = 87.

Here is what the stack and output look like throughout the program:

Command(s)  Stack               Output
72          [72]                ><
.                               >H<
10          [10]                >H<
:           [10 10]             >H<
1           [10 101]            >H<
.           [10]                >He<
:           [10 10]             >He<
8           [10 108]            >He<
:           [10 108 108]        >He<
..          [10]                >Hell<
:           [10 10]             >Hell<
)           [10 11]             >Hell<
:           [10 11 11]          >Hell<
1           [10 11 111]         >Hell<
:           [10 11 111 111]     >Hell<
.           [10 11 111]         >Hello<
#           [10 11 111 3]       >Hello<
2           [10 11 111 32]      >Hello<
#           [10 11 111 32 4]    >Hello<
4           [10 11 111 32 44]   >Hello<
..          [10 11 111]         >Hello, <
:           [10 11 111 111]     >Hello, <
1           [10 11 111 1111]    >Hello, <
..          [10 11]             >Hello, Wo<
4           [10 114]            >Hello, Wo<
.           [10]                >Hello, Wor<
:           [10 10]             >Hello, Wor<
8           [10 108]            >Hello, Wor<
.           [10]                >Hello, Worl<
0           [100]               >Hello, Worl<
.           []                  >Hello, World<
33          [33]                >Hello, World<
.           []                  >Hello, World!<
@

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

1This maybe could be golfed more if you allow the code to intersect itself. – TheNumberOne – 2015-08-29T14:24:28.847

I really don't understand why "1111" is a "W". The ascii code for 'W' is 87. Can somebody explain this to me? – Robert Hickman – 2017-05-25T15:29:21.060

Oh, I see the explanation in the description, but I wasn't aware that . did a % 256 before printing. – Robert Hickman – 2017-05-25T15:41:42.800

10

Carrot (version: ^3), 13 bytes

Carrot is a language of Κριτικσι Λίθος. The syntax is stack^commands, where the stack is a string, and the interpreter outputs everything that's on the stack at the end of the program. The carrot is optional if you have no commands.

Hello, World!

In version ^, the carrot wasn't optional yet if you had no commands, so then it was 14 bytes:

Hello, World!^

ProgramFOX

Posted 2015-08-28T12:23:59.027

Reputation: 6 554

1

+6 carrot.png

– Addison Crump – 2015-11-01T18:11:45.513

Write the version number as "^". – Cows quack – 2015-11-02T05:51:55.293

@ΚριτικσιΛίθος Sure! Done. – ProgramFOX – 2015-11-02T06:40:33.547

Version ^3 makes the ^ optional is you do not want to use any commands. Thus this can be shortened down by one byte. – Cows quack – 2015-11-03T08:40:52.137

@ΚριτικσιΛίθος Cool! Added that. – ProgramFOX – 2015-11-03T08:43:58.303

9

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 Hello, World!. 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 program ends.

For the first 12 iterations, the particle moves as follows.

<style>*{margin:0;padding:0;}</style><svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="420" height="210" 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.

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

So cool. Thanks a lot. – stasoid – 2017-09-15T07:41:08.797

That is amazing. I couldn't figure out how to exit the loop and settled for doing it the long way - big mistake. – Jerry Jeremiah – 2017-10-09T09:39:21.017

9

Hexagony, 30 29 bytes

H;_e;r;2l.;P.QW;l/P1;@;0d;\o;

Try it online!

Source laid out:

    H ; _ e
   ; r ; 2 l
  . ; P . Q W
 ; l / P 1 ; @
  ; 0 d ; \ o
   ; . . . .
    . . . .

One more byte off!

Here's a crappy gif of the program in action.

29 byte gif

Given there's 2 nops inside the program itself, I'm confidant this can be golfed by at least one more byte. I'm willing to offer a bounty for a smaller version.

Old version:

H;e;r;0Pld;P_1;l;;o;Q\;W\;$2@\

Try it online!

Source laid out:

    H ; e ;
   r ; 0 P l
  d ; P _ 1 ;
 l ; ; o ; Q \
  ; W \ ; $ 2
   @ \ . . .
    . . . .

Reuses the same tricks as Martin Ender's answer, i.e Q2 printed is the comma, P0 is the space, P1 is the bang, but manages to be 2 bytes shorter through clever mirroring to reuse several ;s and the o.

Explanation:

Here's a coloured Hexagony grid to show the non-branching path that the pointer takes:

30 byte path

The executing code, ignoring mirrors, is:

H;e;l;;o;Q2;P0;W;d$;o;$2r;0Pl;Wd;P1;@

Filtering out the skipped instructions and the literals that are overwritten by other literals, we are left with:

H;e;l;;o;Q2;P0;W;o;r;l;d;P1;@

Which simply prints "Hello, World!"

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

Jo King

Posted 2015-08-28T12:23:59.027

Reputation: 5 911

9

Zsh, 17 bytes

<<<Hello,\ World!

jimmy23013

Posted 2015-08-28T12:23:59.027

Reputation: 25 688

9

Foo, 14 bytes

"Hello, World!

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

Try it online!

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

Would s print Hello World? ;) – OldBunny2800 – 2016-04-14T21:18:43.647

Probably. – Dennis – 2016-04-14T21:20:14.167

If you find out, you might be able to golf it down to 0 or 1 byte! – OldBunny2800 – 2016-04-14T21:22:13.757

9

PDP-11 (Unix) Assembly, 33 38 bytes

Source (No trailing newline required):

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

Binary output:

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

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

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

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

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

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

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

Unobfuscated source for the same program:

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

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

Random832

Posted 2015-08-28T12:23:59.027

Reputation: 726

9

LLVM IR 4.0.1, 149 145 152 bytes

declare i8@puts(i8*)@t=global[14 x i8]c"Hello, World!\00"define void@main(){call i8(i8*)@puts(i8*getelementptr([14 x i8],[14 x i8]*@t,i1 0,i1 0))ret void}

I'm not very good in LLVM IR, so chances are good, that it's possible with fewer bytes.

Ungolfed Version:

declare i8 @puts(i8*) ; Declare puts from C standard. i8, was the shortest return type possible.

@t=global [14 x i8] c"Hello, World!\00" ; Hello world string as global, to have a pointer to it.

define void @main(){
    call i8(i8*) @puts(i8* getelementptr([14 x i8], [14 x i8] *@t, i1 0, i1 0)) ; Get pointer to constant "Hello, World!" and pass it to puts
    ret void
}

Kritzefitz

Posted 2015-08-28T12:23:59.027

Reputation: 190

9

Mouse, 19 bytes

"Hello, World"33!'$

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

Alex A.

Posted 2015-08-28T12:23:59.027

Reputation: 22 170

9

Prelude, 38 bytes

92480969393782833909095806(^+^+^^+++!)

If you're using the Python interpreter, you'll need to make sure that NUMERIC_OUTPUT is set to False.

Prelude is a relatively simple stack-based language, with 0-9 pushing the corresponding single digits and the only arithmetic being addition and subtraction. In particular, there is no multiplication.

To make the most of the single digit pushing behaviour, I took a look at the code points in various bases. For base 12, we get this:

[[6 0] [8 5] [9 0] [9 0] [9 3] [3 8] [2 8] [7 3] [9 3] [9 6] [9 0] [8 4] [2 9]]

Everything here is a single digit - that's perfect! This means that we can encode each character using two digits via base 12, e.g. H -> 72 (base 10) -> 60 (base 12). That's what the long string of 26 digits at the beginning is for.

The back half of the code then needs to take each pair of digits a, b and give 12*a+b. But remember, Prelude doesn't have multiplication! What it does have, however, is ^ and v, which get the top stack values from the program rows ("voices") above and below. Since this is a one-line program, ^ effectively duplicates the top of the stack, allowing us to do ^+^+^^++ to multiply the top stack element by 12. We then add the second digit with + and output with !. All of this is wrapped in (), which is a BF-like loop which executes while the top stack element is nonzero.

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

9

???, 96 bytes

,;;..;...;.;,,,,;,,"......";...........-,'",-.";;,,,,!;...!;,!!...!;;;!-!-!-!...!,,,,,,!-,!;;;.!

Based on the 95-byte approach by Mitch Schwartz.

Note that the 92-byte Brainfuck solution would yield 97 bytes in ???, because the sequential loops require four more apostrophes.

Alex A.

Posted 2015-08-28T12:23:59.027

Reputation: 22 170

24This is... wait, wrong challenge. – Dennis – 2015-08-29T04:38:34.763

9

Fortran, 28 bytes

print'("Hello, World!")'
end

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

Lynn

Posted 2015-08-28T12:23:59.027

Reputation: 41 980

Which version of Fortran is this? In F77 you'd need some spacing if I'm not mistaken. – Robert Benson – 2016-07-19T12:37:05.003

@RobertBenson F77 would also require fixed form if I'm not mistaken. In any case, this works in GFortran. https://tio.run/##S8svKilKzNNNT4Mw/v8vKMrMK1HXUPJIzcnJ11EIzy/KSVFU0lTnSs1L@f8fAA

– Dennis – 2017-06-06T06:24:55.923

Yes, F77 is fixed format, so you'd need some tabs, which adds to byte-count :( – Robert Benson – 2017-06-07T15:10:32.610

9

Ziim, 1222 bytes

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

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

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

enter image description here
Click for larger version

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

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

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

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

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

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

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

9

Pancake Stack, 1118 1073 bytes

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

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

The relevant operations are:

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

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

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

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

8

USML, 9 bytes

S0h7cWs8h

Try it online!

Explanation:

S0h7cWs8h
S0h7       # Get characters 0-7 of h ("Hello, world!").
    cW     # Get the character "W"
      s8h  # Get the remaining characters, starting at character 8, of h.

This program is an interesting problem, as it has a command that outputs "Hello, world!" (and an empty program will also do this), but the capitalization is not correct. As a result, we need to take some substrings and add in the correct character.

MarkSill

Posted 2015-08-28T12:23:59.027

Reputation: 91

5This is probably the first interesting use of a HW-built-in I've seen in this challenge. – Martin Ender – 2017-04-08T22:15:26.187

8

VSL, 21 bytes

puts(`Hello, World!`)

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

Since VSL is so new, I haven't made a print function yet so this uses the POSIX puts function. Additionally since they aren't strings yet, you have to use byte sequences `...`.

Downgoat

Posted 2015-08-28T12:23:59.027

Reputation: 20 837

Where does this work without a main() function? – Dennis – 2018-03-08T12:02:53.177

8

C#, 85 67 bytes

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

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

pmudra

Posted 2015-08-28T12:23:59.027

Reputation: 101

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

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

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

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

8

BBC BASIC, 20 bytes

PRINT"Hello, World!"

Ahh, this was my first language :)

Beta Decay

Posted 2015-08-28T12:23:59.027

Reputation: 11 590

so BBC Basic does not accept ? as a shorhand for print? – edc65 – 2015-08-28T14:27:16.900

@edc65 I have no idea... I'll try – Beta Decay – 2015-08-28T14:28:23.747

@edc65 It doesn't work in BBC BASIC for Windows – Beta Decay – 2015-08-28T14:53:48.370

Strange, as it's quite standard in basic. A posted an answer as VBA – edc65 – 2015-08-28T14:59:24.360

Is the trailing quotation mark required? – 12Me21 – 2017-02-01T20:58:50.543

@edc65, The "?" is NOT accepted, seems it conflicts with BBC Basic's PEEK() variant. But this is: P."Hello, World!" – user3710044 – 2017-03-19T08:31:35.970

8

R, 20 bytes

cat("Hello, World!")

plannapus

Posted 2015-08-28T12:23:59.027

Reputation: 8 020

8

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!

refi64

Posted 2015-08-28T12:23:59.027

Reputation: 7 567

8

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

Hello, World!

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

LegionMammal978

Posted 2015-08-28T12:23:59.027

Reputation: 14 318

2+1 for scoreboard breaking. – Addison Crump – 2015-11-01T19:31:12.173

8

Brian & Chuck, 42 38 32 bytes

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

Try it online!

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

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

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

Explanation

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

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

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

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

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

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

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

8

Monicelli, 46 bytes

Lei ha clacsonato
"Hello, World!" a posterdati

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

fcalderan

Posted 2015-08-28T12:23:59.027

Reputation: 350

8

Emotinomicon, 18 characters / 30 bytes

Try it here.

!dlroW ,olleH⏪⏬⏩

Explanation:

  !dlroW ,olleH     ⏪   ⏬   ⏩   explanation
                                   begin quote string
    !dlroW ,olleH                   
                                   end quote string
                        ⏪           open loop
                            ⏬       pops and outputs top of stack as character
                                ⏩   close loop

Conor O'Brien

Posted 2015-08-28T12:23:59.027

Reputation: 25 859

8

05AB1E, 14 7* bytes

*14 bytes for the use of the trademarked Ÿ

Code:

”Ÿ™,‚ï!

Try it online!

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

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

This uses CP-1252 encoding

Previous version:

"Hello, World!

Adnan

Posted 2015-08-28T12:23:59.027

Reputation: 33 457

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

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

8

Flummery v3, 165 bytes

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

 [ < > + - ]
 ^

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

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

All in one textbox:

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

Or, in a readable fashion:

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

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

oh heavens what have I made

Conor O'Brien

Posted 2015-08-28T12:23:59.027

Reputation: 25 859

2+1 because this... this is actually brainfucking me. – cat – 2016-03-14T02:33:07.140

What do the ';' do? A combination of . and ,? – Riker – 2016-03-14T02:35:13.697

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

Oh, okay. That makes sense. – Riker – 2016-03-14T02:41:44.400

I hate you so much. So, so much. So much. – Nic Hartley – 2016-04-06T21:29:41.903

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

+1 for the readable version – trichoplax – 2016-04-06T21:31:02.390

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

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

7

Monkeys, 484 460 455 448 bytes

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

Try it online!

How it works

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

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

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

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

First,

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

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

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

Now,

4 DOWN
7 TEACH
7 BOND
4 UP

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

 5:  1
 7:  4
 4: 16

 6: 16

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

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

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

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

7

Fueue,  44  42 41 40 bytes

Thanks to Ørjan Johansen for saving 2 bytes.

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

Try it online!

Explanation

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

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

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

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

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

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

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

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

111 44 32 87 111 114 108 100 33H108 108

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

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

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

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

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

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

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

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

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

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

[44 32 87]111 111

to here:

111 44 32 87 111

We are going to go here instead:

111[44 32 87 111]

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

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

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

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

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

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

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

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

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

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

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

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

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

Got another byte with arithmetic: Try it online!

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

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

7

Javascript, 22 bytes

alert("Hello, World!")

You don't NEED semicolons in Javascipt!

Blue

Posted 2015-08-28T12:23:59.027

Reputation: 22 461

Don't you need them? – OldBunny2800 – 2016-04-14T21:19:56.100

Apparently not for 1 liners (I don't know JS golfably) – Blue – 2016-04-14T21:21:13.723

1The JS interpreter will automatically insert them where it thinks they should be, if they aren't present – MayorMonty – 2016-05-08T22:54:53.037

It does not print to stdout like the spec says – Valentin Lorentz – 2016-06-01T19:45:48.830

1

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

– Blue – 2016-06-01T19:48:38.383

7

Ruby, 18 19 bytes

puts"Hello, World!"

Output wasn't quite right. Thanks Martin

rp.kelly

Posted 2015-08-28T12:23:59.027

Reputation: 91

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

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

7

Retina, 14 bytes


Hello, World!

Try it online!

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

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

K`Hello, World!

Try it online!

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

7

Haskell, 26 bytes

main=putStr"Hello, World!"

Try it online!

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

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

7

Yorick, 21 bytes

write,"Hello, World!"

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

Lynn

Posted 2015-08-28T12:23:59.027

Reputation: 41 980

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

7

Trigger, 40 bytes

HHHeeelll#lllooo,,,   WWWooorrrlllddd!!!

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

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

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

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

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

Gotcha! Thanks! – Albert Renshaw – 2015-09-30T00:37:43.567

7

COBOL, 55 bytes

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

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

Lynn

Posted 2015-08-28T12:23:59.027

Reputation: 41 980

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

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

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

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

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

7

7, 45 bytes

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

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

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

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

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

ETHproductions

Posted 2015-08-28T12:23:59.027

Reputation: 42 391

2+1. This is like BF, O, and assembly in one! – refi64 – 2015-09-03T02:21:47.780

7

ferNANDo, 111 109 bytes

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

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

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

producing:

00001111
00110011
01010101

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

primo

Posted 2015-08-28T12:23:59.027

Reputation: 28 050

7

MATL, 15 bytes

'Hello, World!'

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

Luis Mendo

Posted 2015-08-28T12:23:59.027

Reputation: 68 100

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

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

7

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

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

Hex dump:

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

Original image:

enter image description here

Zoomed in by a factor of 16:

enter image description here

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

SuperJedi224

Posted 2015-08-28T12:23:59.027

Reputation: 9 433

7

beeswax, 15 bytes

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

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

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

_`Hello, World!

or

*`Hello, World!

Or slightly less boring:

!dlroW ,olleH`*

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

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

A little more interesting, but 1 byte longer:

!lo olH`_`el,Wrd

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

r  l
 l o
  ``
ol`*`,d!
   ``
   e H
   W

And the same, using the beeswax prettyprint tool:

      r     l
       l   o
        ` `
   o l ` * ` , d !
        ` `
       e   H
      W

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

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

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

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

21
3β0
 45

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

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

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

M L

Posted 2015-08-28T12:23:59.027

Reputation: 2 445

7

Pris, 107 bytes

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

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

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

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

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

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

[...]

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

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

Conor O'Brien

Posted 2015-08-28T12:23:59.027

Reputation: 25 859

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

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

7

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

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

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

Try it online!

Verification

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

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

7

ELF 64-bit LSB executable (Linux), 104 bytes

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

This sets as many proper headers as possible without affecting the byte count, prints a trailing linefeed and exits cleanly with exit code 0.

Try it online!

Verification

$ cksum hw64
3288151474 104 hw64
$ file hw64
hw64: ELF 64-bit LSB executable, x86-64, version 1, statically linked, corrupted section header size
$ ./hw64
Hello, World!
$ echo $?
0

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

7

Sesos, 24 21 bytes

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

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

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

How it works

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

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

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

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

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

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

6

Lost, 56 54 45 bytes

Two bytes saved thanks to @MartinEnder

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

Try it online!

Explanation

This is now a bit outdated, I will try to update soon

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

Here's how this one works:

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

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

  • % turns the safety off.

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

  • ! jumps unconditionally.

  • ( pops a value and saves it for later.

Ok now we are read to dive in.

The main code is the following line

"Hello, WorldvU"-+@

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

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

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

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

Now the problem is that some of the programs accumulate junk before we catch them, for example if you start on the 1 you might get a 1, or even worse if you start in the string going west you will get %>@+!(. So we add some code to clear the stack. >?!| should do the trick, and if we use the > from earlier we can save a byte.

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

Now there is just one problem. If the program starts on ! going north or south, it will jump the stream back to itself and loop forever. To fix this we add a v below the !.

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

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

Wheat Wizard

Posted 2015-08-28T12:23:59.027

Reputation: 33 549

6

APL, 17 bytes

⎕←'Hello, World!'

This is the portable way of printing from a full program.

In the ngn/apl demo, you can omit the ⎕← for 15 bytes.

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

6

C++, 48 bytes

(must be compiled with g++)

puts is slightly more concise than std::cout, shaving 6 bytes off of the other c++ answer.

#include<cstdio>
main(){puts("Hello, World!");}

DJMcMayhem

Posted 2015-08-28T12:23:59.027

Reputation: 37 405

1With g++, you can eliminate the space on line 1 and the int on line 2. – Dennis – 2015-08-29T03:56:55.873

@Dennis, done. I think this is the shortest possible in C++. – DJMcMayhem – 2015-08-29T07:02:26.803

1This is not legal C++ code. The return type of main must be int and cannot be empty. – Hubi – 2015-08-31T09:34:16.133

@Hubi but it does correctly compile and run if you use g++. – DJMcMayhem – 2015-08-31T15:58:35.717

@DJ yes, but only because of the C compatibility of the C++ compiler! If you compile your source with the flag "-Wall", you get a warning that ISO forbids no return type! – Hubi – 2015-08-31T19:45:56.530

int puts(...); instead of #include&lt;cstdio&gt; makes it 3 bytes shorter. Or not... – Qwertiy – 2015-09-03T10:38:04.570

In Obj-c you can use #import instead of #include, 1 shorter :D – Albert Renshaw – 2015-09-29T21:26:56.827

@DJMcMayhem The fact, that compiler compiles something, does not mean, that it is correct. C++ does not support default int. – Zereges – 2015-10-25T11:20:12.577

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

– DJMcMayhem – 2015-10-25T21:15:12.233

In this code yields two errors with g++ in Mac OS. – CroCo – 2016-01-04T10:57:11.583

It's 47 bytes, not 48 – ASCII-only – 2017-08-18T12:14:46.707

6

Beatnik, 148 Bytes

It could probably be done better, but this is one of the first times I used a stack based language.

Beatnik determines commands and values based in the scrabble score for the words, but it (thankfully) doesn't check them against a dictionary.

K QQQQQQQG ZD XO K QQJA KD ZD XO K KG KD ZD ZD ZD XO XO K B KD ZD XO K QQQQF ZD ZD XO K QQQD XO K A Z KD XO ZD XO K B KD XO ZD XO K J Z XO K QQQB XO

Python interpreter can be found here

A breakdown of what I've done

K QQQQQQQG  # push 72         72
ZD          # duplicate       72 72
XO          # output H        72            
K QQJA      # push 29         29 72
KD          # add             101
ZD          # duplicate       101 101
XO          # output e        101           
K KG        # push 7          7 101
KD          # add             108
ZD          # duplicate       108 108
ZD          # duplicate       108 108 108
ZD          # duplicate       108 108 108 108
XO          # output l        108 108 108   
XO          # output l        108 108       
K B         # push 3          3 108 108
KD          # add             111 108
ZD          # duplicate       111 111 108
XO          # output o        111 108       
K QQQQF     # push 44         44 111 108    
ZD          # duplicate       44 44 111 108
ZD          # duplicate       44 44 44 111 108
XO          # output ,        44 44 111 108
K QQQD      # push 32         32 44 44 111 108    
XO          # output <space>  44 44 111 108              
K A         # push 1          1 44 44 111 108
Z           # subtract        43 44 111 108
KD          # add             87 111 108
XO          # output W        111 108    
ZD          # duplicate       111 111 108
XO          # output o        111 108       
K B         # push 3          3 111 108
KD          # add             114 108
XO          # output r        108           
ZD          # duplicate       108 108
XO          # output l        108           
K J         # push 8          8 108
Z           # subtract        100           
XO          # output d                      
K QQQB      # push 33         33
XO          # output                        

MickyT

Posted 2015-08-28T12:23:59.027

Reputation: 9 062

Can you add Scrabble scores to the explanation? – CalculatorFeline – 2017-06-05T04:34:02.307

The version using valid scrabble words is only 100 bytes longer. – ppperry – 2017-08-02T00:44:49.627

6

Parenthetic, 766 698 630 bytes

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

Try it online!

Still got a lot to golf. This version uses a single definition

(define f (lambda (a b) (char (+ (* a 13) 30 b))))

In other words, each char is encoded by two numbers a and b, for which 30 + 13*a + b is calculated (e.g. H = 73 = 30 + 3*13 + 3) .

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

nice work ... I thought it could be done better – MickyT – 2015-09-04T01:01:12.943

608 bytes using (define f (lambda (a b) (char (- (* 6 19) (* a 13) b)))) – Leaky Nun – 2017-08-23T11:00:14.397

604 bytes after golfing Leaky Nun's answer slightly – Sherlock9 – 2017-08-23T13:07:15.317

6

Glava 1.4, 16 bytes

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

p("Hello, World!

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

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

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

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

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

GamrCorps

Posted 2015-08-28T12:23:59.027

Reputation: 5 255

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

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

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

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

6

Shtriped, 199 bytes

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

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

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

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

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

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

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

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

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

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

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

s n \ finally, print n as a string

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

Calvin's Hobbies

Posted 2015-08-28T12:23:59.027

Reputation: 48 376

5

Chip, 174 166 106 97 bytes

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

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

Try it online!

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

Ungolfed (134 bytes):

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

How the ungolfed version works:

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

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

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

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

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

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

Golfing it:

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

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

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

Phlarx

Posted 2015-08-28T12:23:59.027

Reputation: 946

5

K (oK), 20 19 bytes

!`0:"Hello, World!"

Try it online!

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

Alternative solution, 20 bytes, clean exit

{}`0:"Hello, World!"

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

Try it online!

Almost-solutions

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

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

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

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

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

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

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

– primo – 2017-02-10T11:16:40.570

5

Alice, 19 18 bytes

Thanks to Sp3000 for saving 1 byte.

"&O@!dlroW ,olleH

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

"!dlroW ,olleH"d&O@

Try it online!

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

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

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

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

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

Try it online!

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

"Hello, World!"o@

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

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

5

Aceto, 19 bytes

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

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

Laura Bostan

Posted 2015-08-28T12:23:59.027

Reputation: 181

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

5

Cubically, 124 123 111 99 78 bytes

-11 bytes thanks to TehPers, -12 thanks to language updates, -21 thanks to user202729

RU+432@6+50-4@6+3-4@6@6+1-00@6-331@6-00@6+4110@6+0000@6+1-00@6-0@6-2+4@6-331@6

Generated via this amazing algorithm.

There is a good explanation of Cubically in this question.

Cubically, the Rubik's Cube Programming Language, is the most complex language I have ever written, or dealt with, for that matter. It entirely comprises of operations on a single 3x3 Rubik's Cube in its memory, and one extra value, the "notepad".

The only way to perform mathematical operations is to take values from a certain cube face and add/subtract/multiply/divide it with the scratch pad value, replacing said value.

For example, performing /0 divides the notepad value by the sum of all integers on the 0-indexed face, or the first face.

The cube starts out initialized like this:

   000
   000
   000
111222333444
111222333444
111222333444
   555
   555
   555

Performing a 90-degree clockwise turn on the right face will make the cube look like this:

   002
   002
   002
111225333044
111225333044
111225333044
   554
   554
   554

Version from TehPers:

Here's a run-down of how the program works: (Note that I have replaced @6 with @ in the code, but changing each instance in the rest of this answer would be too tedious and I need to get back to real life.)

  • +53 adds the DOWN face and RIGHT faces into the notepad, in this case, 45 and then 27. This results in 72, the ASCII code for H.
  • @6 prints the notepad value as ASCII.
  • :2 sets the notepad to the value of the FRONT face (18).
  • /1 divides the notepad by the LEFT face (9), resulting in 2.
  • +551 Adds the DOWN face (45) twice, then the LEFT face (9). As you can see, without rotating the cube, the faces will contain a total value equal to 9 times the index. For example, face index 5 has a value of 45, face index 1 has a value of 9, and so forth. After rotating the cube, this no longer applies.
  • @6 again prints the notepad value, or e.
  • :5 sets the notepad to the value of the DOWN face (45).
  • +52 adds the DOWN face (45) and the FRONT face (18) to the notepad.
  • @66 prints the current notepad value as a character twice. At this point Hell has been printed, which should be good enough for this language. :P
  • :3/1 sets the notepad to the value of the RIGHT face (27), then divides the notepad by the value of the LEFT face (9), resulting in 3. Do you see the pattern yet?
  • +552 adds 108 to the notepad, or 9*(5+5+2). Remember, if you rotate the cube, then the faces will not necessarily be multiples of 9!
  • @6 prints the notepad value as a character, finishing the word "Hello".
  • From this point there is nothing interesting. The program follows the pattern of setting the notepad value to whatever c % 9 is (where c is the target character), then adding multiples of 9 to the notepad get to the target character. The faces are not rotated, so this isn't exactly the best showcase program for Cubically, but it's certainly simpler than what could be accomplished with rotating the faces. There may be a shorter way to write this program using rotations, though.

Original (written by hand >.<)

+53@6+1F2L2+0@6L2F2U3R3F1L1+2@66L3F3R1U1B3+0@6:4U1R1+00@6-000@6+50000@6+000000@6+2-000000@6-5+4000@6-00@6/0+00@6:0+0/0+00@6

The above Hello World program uses arbitrary turns that I fiddled with until they got some desired values. Eventually, I got the top face to add up to 4 and made do with that.

Here's a run-down of how the program works:

  • +5+3 adds the DOWN face and RIGHT faces into the notepad, in this case, 45 and then 27. This results in 72, the ASCII code for H.
  • @6 prints the notepad value as ASCII.
  • +1 adds the LEFT face to the notepad value, resulting in 81.
  • F2 turns the FRONT face to look like this.
  • L2 turns the LEFT face to look like this.
  • +0 adds the UP face to the notepad, resulting in 101.
  • @6 prints memory as ASCII e.
  • L2F2U3R3F1L1 turns the cube to look like this.
  • +2 adds the FRONT face to the notepad, resulting in 108. @66 prints as ASCII twice ll. At this point Hell has been printed, which should be good enough for this language. :P
  • L3F3R1U1B3 turns the cube to look like this.
  • +0 adds the UP face to the notepad (resulting in 111), @6 prints it as ASCII o.
  • :4 sets the notepad to the BACK face 36.
  • U1R1 turns the cube to look like this. The cube is not turned again 'cause this was about as good of a setup I could get.
  • +0+0 adds the UP face to the notepad twice, resulting in 44.
  • @6 prints as ASCII ,.
  • -000 subtracts 12 from the notepad (32). @6 prints as ASCII .
  • From this point there is nothing interesting except messing with the existing faces, particularly the top face (which has a convenient value 4), to print the remaining characters.

MD XF

Posted 2015-08-28T12:23:59.027

Reputation: 8 337

It's not complex, just insanely difficult :o – HyperNeutrino – 2017-06-15T00:45:44.843

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

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

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

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

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

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

5

Sad-Flak, 199+3 bytes = 202 bytes

3 bytes for the -A arg. This lang uses a "codepage", where ≤≥ are one byte each (that is, I have a thing that replaces ` and ~ with those chars and runs it)

32
({}≤()≥)
(≤()≥)
99
({}≤()≥)
((<>[≤()≥]))
7
({}≤()≥)
((<>))≤()≥
5
({}≤()≥)
(≤()≥)
109
({}≤()≥)
(<>)(≤()≥)
85
({}≤()≥)
(≤()≥)
30
({}≤()≥)
(≤()≥)
42
({}≤()≥)
({≤()≥})(({()}))({()})(())
70
({}≤()≥)
≤≥

Try it online!

Explanation:

The main idea behind this is that the way Sad-Flak works, you can easily get it to repeat a line a constant number of times.

in Sad-Flak, there is a line pointer. The line pointer starts at the beginning

-> 32
   ({}≤()≥)
   (≤()≥)
   99
   ({}≤()≥)
   ((<>[≤()≥]))
   7
   ({}≤()≥)
   ((<>))≤()≥
   5
   ({}≤()≥)
   (≤()≥)
   109
   ({}≤()≥)
   (<>)(≤()≥)
   85
   ({}≤()≥)
   (≤()≥)
   30
   ({}≤()≥)
   (≤()≥)
   42
   ({}≤()≥)
   ({≤()≥})(({()}))({()})(())
   70
   ({}≤()≥)
   ≤≥

however, the 32 is not actually a command. it is a simple way to express 32 blank lines. I could expand them for the demonstration, but then it would be unreadable. anyway.

So, the line pointer points at the first of 32 blank lines. When the line pointer points at a non-blank line, it will execute that line. when the line pointer points at a blank line, it will execute the first non-blank line after that line. that means we execute ({}≤()≥). What does this line do? This lang is a brainflak derivative, btw, so some of the brackets do the same thing, but not all

(        push...
 {}      pop off the main stack and evaluate to that value, plus
   ≤     jump by the amount inside, evaluate to that value for the purpose of other commands
    ()   1
      ≥
       )

so, this pops off the stack, adds one to it while jumping one forward, then pushes back on the stack. What is jumping? why are we jumping in the middle of a line?

Jumping in Sad-Flak is rather different to most other langs. Jumping does not take immediate effect, but rather moves the line pointer. when the line pointer is moved, nothing happens until the current line is finished executing. when it is finished, we see which line the line pointer points at, and execute that. If the line pointer didn't get moved, the same line gets executed again, and again, until it gets moved. however, all lines in this program either are blank, or they jump or halt. So, this line moves the line pointer one forward and increments top of stack.

What is the line pointer pointing at now? it's still on a blank line, so it does the same thing again, and again, until it gets to the line that it keeps executing

   32
-> ({}≤()≥)
   (≤()≥)
   99
   ({}≤()≥)
   ((<>[≤()≥]))
   7
   ({}≤()≥)
   ((<>))≤()≥
   5
   ({}≤()≥)
   (≤()≥)
   109
   ({}≤()≥)
   (<>)(≤()≥)
   85
   ({}≤()≥)
   (≤()≥)
   30
   ({}≤()≥)
   (≤()≥)
   42
   ({}≤()≥)
   ({≤()≥})(({()}))({()})(())
   70
   ({}≤()≥)
   ≤≥

Then, it executes it one last time, before moving to the next line. this end up with the charcode of ! on the stack (32 blanks + 1 actual line)

   32
   ({}≤()≥)
-> (≤()≥)
   99
   ({}≤()≥)
   ((<>[≤()≥]))
   7
   ({}≤()≥)
   ((<>))≤()≥
   5
   ({}≤()≥)
   (≤()≥)
   109
   ({}≤()≥)
   (<>)(≤()≥)
   85
   ({}≤()≥)
   (≤()≥)
   30
   ({}≤()≥)
   (≤()≥)
   42
   ({}≤()≥)
   ({≤()≥})(({()}))({()})(())
   70
   ({}≤()≥)
   ≤≥

this line ((≤()≥)) pushes a new 1 to the stack, and moves the line pointer one forward, onto a new blank line, to do basically the same thing as it did before. however it puts charcode of e. and also the next line is this: ((<>[≤()≥])). What is this complex line? well:

((        push twice...
  <>      value popped from stack, and pushed onto the offstack for later retrieval
    [     minus ...
     ≤    (jump but eval to the argument still)
      ()  1
        ≥
         ]
          ))

so, this pops the e off the stack, and replaces it with two ds, while leaving an e on the off stack for later retrieval, and also jumping the line pointer to the next line. we have two, because one will be changed into l, because it saves bytes from pushing a 1 and incrementing it up to the next letter. we don't do this for all of them because it also cost bytes popping and pushing back onto the stack, as well as fitting the jump in there.

from now on, I'm skipping the blank lines and the increment top of stack lines, because this explanation is long enough already.

after adding 8 to yield l

((          push twice...
  <>        a value popped from stack, also pushed to offstack
    ))
      ≤     jump ...
       ()   1
         ≥

add 6 to yield r: this one again: (≤()≥) new value at 111 (o):

(           push...
 <>         popped value, also pushed to offstack.
   )
    (       push...
     ≤      (jump and eval to same as...)
      ()    1
        ≥
         )

so this pushes to the off stack while keeping it on the stack, and pushing another 1 on the stack.

new 87 (W): this again: (≤()≥)

new 32 (space): same again: (≤()≥)

new 44 (,): ({≤()≥})(({()}))({()})(()) woah, what is that? put simply, it is just pushing onto the main stack what we pushed on to the offstack, then a 1 to make into a H:

(             push...
 {            pop from the off stack, evaluate to that multiplied by...
  ≤           jump and eval to...
   ()         1
     ≥
      }
       )         this pushes o

        ((         push twice...
          {        multiply an offstack popped value by...
           ()      1
             }
              ))     this pushes l twice

                (        push...   
                 {       offstack popped value times...
                  ()     1 
                    }
                     )      this pushes e

                      (    push...
                       ()  1
                         )

new 72 (H): ≤≥: this is the halt command and it stops the program

That pushed !dlroW ,olleH char codes, which then gets printed, but backwards because it is a stack. "Hello, World!"

Destructible Lemon

Posted 2015-08-28T12:23:59.027

Reputation: 4 669

5

Pyramid Scheme, 857 bytes

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

Try it online!

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

Conor O'Brien

Posted 2015-08-28T12:23:59.027

Reputation: 25 859

5

Magic Number, 174 bytes

0010000033001000010000100001080010000114001000011100100000870010000032001000004400100001110010000108001000010800100001010010000072006006006006006006006006006006006006006006

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

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

Daniel O

Posted 2015-08-28T12:23:59.027

Reputation: 51

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

5

Pain-Flak, 152 bytes

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

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

Try it online!

How it works

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

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

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

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

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

  • Line 1 pushes garbage on the first stack.

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

    This switches to the second stack.

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

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

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

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

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

5

Forth, 17 bytes

.( Hello, World!)

mbomb007

Posted 2015-08-28T12:23:59.027

Reputation: 16 876

." Hello World! is one byte shorter. – Lynn – 2015-08-28T20:27:32.150

1." may only be used within a function declaration. ." : error(-14): use only during compilation – mbomb007 – 2015-08-28T20:47:05.253

Why the space in .( Hello,? – Erik the Outgolfer – 2016-06-16T14:56:10.503

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Forth requires spaces between tokens. The ending ) is the exception to the rule. – mbomb007 – 2016-06-16T14:56:48.613

@mbomb007 It's unfair that ." is only in functions. – Erik the Outgolfer – 2016-06-16T15:03:12.907

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Same with loops. – mbomb007 – 2016-06-16T16:15:49.083

5

Pascal, 32 bytes

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

aditsu

Posted 2015-08-28T12:23:59.027

Reputation: 20 689

5

Julia, 22 bytes

print("Hello, World!")

Short and sweet.

Alex A.

Posted 2015-08-28T12:23:59.027

Reputation: 22 170

5

Unlambda, 36 bytes

`.!`.d`.l`.r``.W`. `.,``.l`c`.H.e.oi

Unlambda is a minimal functional programming language based on combinatory logic. It uses prefix notation; `fx is an application of f to x. Specifically, .c is a primitive that takes some v, prints the character c as a side-effect, and returns v. Thus, the usual program would be to take i, apply .H to it, apply .e to it, etc., giving you `.!`.d`.l...

This 36-byte solution is due to irori on anarchy golf. It uses the primitive c, which I think is kind of like call/cc, to avoid having to write .o and .l twice. I have no idea how it precisely works. The sort-of equivalent Lisp syntax would be:

(print-!
  (print-d
    (print-l
      (print-r
        ((print-W
           (print-space
             (print-comma
               ((print-l
                  (call-cc (print-h print-e)))
                print-o))))
         id)))))

Lynn

Posted 2015-08-28T12:23:59.027

Reputation: 41 980

5

Mind, 26 bytes

The program is encoded in Shift_JIS, and looks like this:

enter image description here

(I'm not allowed to post Japanese characters here.) It means something like:

MAIN is:
display
"Hello, World!"

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

Lynn

Posted 2015-08-28T12:23:59.027

Reputation: 41 980

5

Inform 7, 36 bytes

Include C by G.Z:say "Hello, World!"

This code requires at least version 1/150829 of the code golfing extension.

curiousdannii

Posted 2015-08-28T12:23:59.027

Reputation: 602

3I got rid of my old version. – Lynn – 2015-08-29T05:20:08.743

5

NULL, 91 bytes

int("8bxyd2qvpj6uq6gh9u8hlrjfwqkx8i2pvid5auhrsrbpp8gsczv6ye26ew0pkx05wem94m9zqkn8prqir",36)

This number represents a program, and it has 126 digits in decimal representation. I use base-36 here to shorten the number. It seems acceptable because the interpreter of NULL uses the python eval on the program before executing it (presumably to allow specifying the program as a product of prime numbers). The prime factorization (used while executing the program) is

3*3*3*17*31*73*127*139*151*157*167*197*239*241*307*367*367*419*479*499*
547*599*619*677*751*839*919*947*947*1019*1039*1097*1129*1217*1249*1301*
1303*1327*1433*1499*1543*1613*1709*1777*1873*1951*1993*2063

I found this program by using something like A* search. It tracks the state of the NULL interpreter and two additional values:

  • print - number of characters in the Hello, World! message it managed to output so far
  • length - natural logarithm of the number that represents the program

For each state, it picks 10 possible commands the language has (there are 14, but the rest are too uncomfortable to search), and calculates 10 new states. To find the shortest program, it holds the states in a priority_queue, arranged by the following cost function:

print - length / 25

If I use a fudge factor much different from 25, it either keeps searching forever (until it eats all RAM) or finds sub-optimal solutions.


BTW there is a bug in the interpreter in the generation of prime numbers. I fixed it by simplifying the code this way:

def factor_g(include_builtin_list = True):
    if include_builtin_list:
        for x in plist: yield x
    k = plist[-1] + 2
    while True:
        yield k
        k += 2

anatolyg

Posted 2015-08-28T12:23:59.027

Reputation: 6 787

5

goruby, 6 bytes

h:H,:W

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

primo

Posted 2015-08-28T12:23:59.027

Reputation: 28 050

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

5

Bodyless HTTP response headers, 134 bytes

HTTP/1.1 200 OK
content-type: text/html
link: <data:text/css,body:after{content:"Hello, World!"}>; rel=stylesheet
content-length: 0

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

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

Qwertiy

Posted 2015-08-28T12:23:59.027

Reputation: 2 507

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

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

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

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

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

5

Mascarpone, 29 bytes

[!dlroW ,olleH]$.............

The esolangs page notes that

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

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

Peter Taylor

Posted 2015-08-28T12:23:59.027

Reputation: 37 961

I know this is way late, but you can loop by having an operation call itself [!dlroW ,olleH]$[/.:!]v*:! – BlackCap – 2017-07-21T14:57:23.587

5

Self-modifying Brainfuck, 28 19 bytes

represents a literal NUL byte.

<[.<]␀!dlroW ,olleH

Try it online

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

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

<[.+<]␀!dlroW ,olleH

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

mbomb007

Posted 2015-08-28T12:23:59.027

Reputation: 16 876

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

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

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. – None – 2017-05-01T01:13:02.140

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

5

Rotor, 14 bytes

"Hello, World!

Nothing too fancy here. Like Pyth, quotes and most other structures are implicitly closed at EOF.

Try it online.

Check out Rotor.

quartata

Posted 2015-08-28T12:23:59.027

Reputation: 8 270

5

Candy, 18 bytes + 1 = 19 bytes

Push (technically queue) string (character-by-character) onto the stack, and loop to print

"Hello, World!"(;)

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

Dale Johnson

Posted 2015-08-28T12:23:59.027

Reputation: 509

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

– cat – 2015-12-14T14:23:43.630

There was a suggestion on one of my other posts that suppressing STDOUT should have a cost, so I followed that here. But it doesn't seem to be consistently followed. – Dale Johnson – 2015-12-14T22:44:33.787

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

– cat – 2015-12-14T22:56:07.557

5

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

DJMcMayhem

Posted 2015-08-28T12:23:59.027

Reputation: 37 405

1

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

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

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

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

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

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

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

Ok, two more: try it online

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

Another two: try it online

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

5

Morse code, 48 bytes

.... . .-.. .-.. --- .-- --- .-. .-.. -.. -.-.--

f1rstguess

Posted 2015-08-28T12:23:59.027

Reputation: 181

3Hello, and welcome to PPCG! This question is kind of special, so Morse Code is allowed, but please don't answer other questions in Morse Code. This is because Morse Code is not a valid programming language. – NoOneIsHere – 2016-09-03T14:52:04.207

5

Wise, 135 + 3 = 138 bytes

~-<<<~-<<<::^~-<~-<<<~-<<~-:::^~-<<<~-^::?:>~-<~-:?::^~-<<~-<~-<<::^~-<<<<<:<::^<~-<<~-<~-<~-|!::^~-<~-<~-<<<~-<!:::^~-<<<^::^~-<<<<<~-

Try it online!

Wheat Wizard

Posted 2015-08-28T12:23:59.027

Reputation: 33 549

4

TP, 17,806 bytes

TP is a language I created based on using toilet paper.

The main operation is USE TP which removes a sheet (1) from the current roll (cell), each roll starts at 255 sheets. There is also GET TP which adds a new roll to the toilet paper pile. There is also the accompanying NEW TP and OLD TP which switches to a newer roll or older roll respectively. The final notable command is DIS TP which displays the ASCII value for the current roll.

This is included as tphelloworld.tp for the interpreter download.

This can definitely be shorter.

USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

GET TP
NEW TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
USE TP
DIS TP

Notes About the Interpreter

The interpreter always removes whitespace from the working line, so USE TP becomes USETP, this allows a 1 byte decrease per line. Since the interpreter uses Python, I believe newline style (CR+LF, LF) doesn't matter. A thing that I'm trying to think of a way to do is add a separator (command; command). If I figure out a way to implement that, then the filesize can be drastically reduced.

ender_scythe

Posted 2015-08-28T12:23:59.027

Reputation: 104

Doing a quick estimate you can probably get this down to around 6500 bytes. I would write it up but I can't at the current time (if I get some time this weekend I'll run through it). – Teal pelican – 2016-11-18T16:00:02.330

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

6damn, that's a lot of trees cut down... – FlipTack – 2016-11-18T18:27:23.917

@Flp.Tkc Maybe I should make a version where you plant trees? – ender_scythe – 2016-11-18T18:33:59.767

Calculation for chars(6405 bytes)
H=(255-72)"USE TP "+"DIS TP "
e="GET TP NEW TP "(255-101)
"USE TP "+"DIS TP "
l="GET TP NEW TP "+(255-108)"USE TP "+"DIS TP "
l="DIS TP "
o="GET TP NEW TP "+(255-111)
"USE TP "+"DIS TP "
,="OLD TP OLD TP OLD TP "+(72-44)"USE TP "+"DIS TP "
=(44-32)
"USE TP "+"DIS TP "
W="NEW TP "+(101-87)"USE TP "+"DIS TP "
o="NEW TP NEW TP DIS TP "
r="GET TP NEW TP "+(255-114)
"USE TP "+"DIS TP "
l="OLD TP OLD TP DIS TP "
d=(108-100)"USE TP "+"DIS TP "
!="OLD TP "+(87-33)
"USE TP "+"DIS TP "
– Teal pelican – 2016-11-21T09:03:06.780

I messed up the formatting a little but the basic premise is using 5 TP's and just going to the nearest TP with more than we need the removing it from it. – Teal pelican – 2016-11-21T09:06:21.750

@Tealpelican That works? – ender_scythe – 2016-11-21T14:48:35.880

4

uBASIC, 21 bytes

1PRINT"Hello, World!"

uBASIC is the most basic BASIC.

Exits with an error (no trailing newline).

It took me until just now to realize I don't need a space between 1 and PRINT...

Try it online!

Pavel

Posted 2015-08-28T12:23:59.027

Reputation: 4 211

4

OIL, 15 bytes

Hello, World!
4

OIL is a self-modifying turing-machine-like programming language with random access, and weak typing. The first line does nothing, because it's not one of the integers currently defined as commands, so it is just skipped. The second line is a 4, the print command, which takes one argument (the next line) and prints the value at that location. Since the next line doesn't exist, it's uninitialized and defaults to 0, which causes OIL to print the contents of the 0th line, Hello, World!.

L3viathan

Posted 2015-08-28T12:23:59.027

Reputation: 2 921

4

Klein, 50 + 6 = 56 bytes

+3 bytes due to the -A flag.

+3 bytes for 000 topology (though in my testing, pretty much all valid topoligies work)

89*45:**:(1+:7+::3+:(492+*84*9:*6+):3+6:3**)84*1+@

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

Okx

Posted 2015-08-28T12:23:59.027

Reputation: 10 558

You do have to add 3 for the topology you are using and 3 for the -A flag, (but so does everyone else, so it shouldn't hurt you) – Wheat Wizard – 2017-05-18T19:09:50.863

@WheatWizard Yep, just added that in. – Okx – 2017-05-18T19:11:13.953

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

– Dennis – 2017-05-19T00:58:41.440

@Dennis Would that be +2 bytes then? – Okx – 2017-05-19T06:15:54.443

Could you make the title Klein, 50 + 6 = 56 bytes as it kinda messes up the catalogue? – caird coinheringaahing – 2017-05-22T14:39:48.343

@RandomUser Sure thing. – Okx – 2017-05-22T15:38:18.773

4

Klein, 48 + 3 + 3 = 54 bytes

89*55+:*:(1+:7+:::(3+:(485*+48*699*+):3+))148*+@

Try it online!

Riley

Posted 2015-08-28T12:23:59.027

Reputation: 10 445

4

COBOL, 65 Bytes

PROGRAM-ID.H.PROCEDURE DIVISION.DISPLAY 'Hello, World!'.STOP RUN.

Just from what I remember. Probably doesn't work but I can't tell since my machines set up to run COBOL are long-gone.

Bakna

Posted 2015-08-28T12:23:59.027

Reputation: 41

2Welcome to the site! – DJMcMayhem – 2017-05-25T15:39:35.400

This works just fine with GNU COBOL assuming you set the -F (or -free) flag, but you're missing a comma in your string. https://tio.run/##S85Pys/RTc8r/f8/IMjfPcjRV9fTRc9DD8hxdnUJDXJVcPEM8wz29PfTc/EMDvBxjFRQ90jNycnXUQjPL8pJUVTX@///X3JaTmJ68X9dNwA

– Dennis – 2017-07-17T20:52:06.373

So I am. I shall fix this. – Bakna – 2017-07-17T20:53:08.550

4

Casio Basic, 15 Bytes

"Hello, World!"

I think it explaines itself well enough...

ADDB

Posted 2015-08-28T12:23:59.027

Reputation: 161

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

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

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

4

Memescript, 820 bytes

what the frick frack backtrack snick snack quarterback diddily dack diddily dack quarterback diddily dack diddily dack backtrack diddily dack backtrack diddily dack biofeedback quarterback diddily dack diddily dack quarterback quarterback diddily dack quarterback diddily dack diddily dack patty wack quarterback diddily dack slack mack frick frack thumbtack snick snack snick snack quarterback diddily dack patty wack sidetrack quarterback diddily dack snick snack patty wack patty wack biofeedback quarterback diddily dack diddily dack sidetrack diddily dack sidetrack quarterback diddily dack diddily dack patty wack quarterback diddily dack patty wack slack mack quarterback diddily dack patty wack crackerjack quarterback diddily dack slack mack frick frack thumbtack snick snack patty wack quarterback diddily dack

Explanation:

what the                     open program
frick frack backtrack        push 10
snick snack quarterback      multiply by 7 (70)
diddily dack diddily dack    add 2 (72)
quarterback diddily dack     print as char ('H')
diddily dack backtrack       add 10 (82)
diddily dack backtrack       add 10 (92)
diddily dack biofeedback     add 9 (101)
quarterback diddily dack     print as char ('e')
diddily dack quarterback     add 7 (108)
quarterback diddily dack     print as char ('l')
quarterback diddily dack     print as char ('l')
diddily dack patty wack      add 3 (111)
quarterback diddily dack     print as char ('o')
slack mack                   pop
frick frack thumbtack        push 11
snick snack snick snack      multiply by 4 (44)
quarterback diddily dack     print as char (',')
patty wack sidetrack         subtract 12 (32)
quarterback diddily dack     print as char (' ')
snick snack patty wack       multiply by 3 (96)
patty wack biofeedback       subtract 9 (87)
quarterback diddily dack     print as char ('W')
diddily dack sidetrack       add 12 (99)
diddily dack sidetrack       add 12 (111)
quarterback diddily dack     print as char ('o')
diddily dack patty wack      add 3 (114)
quarterback diddily dack     print as char ('r')
patty wack slack mack        subtract 6 (108)
quarterback diddily dack     print as char ('l')
patty wack crackerjack       subtract 8 (100)
quarterback diddily dack     print as char ('d')
slack mack                   pop
frick frack thumbtack        push 11
snick snack patty wack       multiply by 3 (33)
quarterback diddily dack     print as char ('!')

No one

Posted 2015-08-28T12:23:59.027

Reputation: 71

4

Triangular, 66 bytes

8.9,*<>@5\,1*6<>-+@7\,+3@@+<>@:3_7+\,3@-*43@<>*9-@p@3+\@_3@-8@-6@<

Try it online!

How it works

Expanded:

          8
         . 9
        , * <
       > @ 5 \
      , 1 * 6 <
     > - + @ 7 \
    , + 3 @ @ + <
   > @ : 3 _ 7 + \
  , 3 @ - * 4 3 @ <
 > * 9 - @ p @ 3 + \
@ _ 3 @ - 8 @ - 6 @ <

Executed commands, ignoring directional commands:

89*@56*1-+@7+@@3+@:3_7+@4*-@3*9-@p@3+@6-@8-@3_@

Commands used, ignoring directional commands:

  • 1 to 9: push the literal value
  • +: add
  • -: subtract
  • *: multiply
  • _: divide
  • :: duplicate top of stack
  • p: pop top of stack
  • @: print top of stack as charcode

Triangular is a 2D stack-based language which uses postfix notation.

Leaky Nun

Posted 2015-08-28T12:23:59.027

Reputation: 37 559

4

MY, 73 bytes

Here's the hex:

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

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

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

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

Zacharý

Posted 2015-08-28T12:23:59.027

Reputation: 3 340

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

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

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

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

4

Husk, 8 bytes

¨H◄⁰,ω]!

Try it online!

Husk got compressed strings!

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

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

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

Leo

Posted 2015-08-28T12:23:59.027

Reputation: 6 873

4

Sqirrel - Peter, 903 bytes

A couple notes about my golfing:

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

Here is my attempt:

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

Jerry Jeremiah

Posted 2015-08-28T12:23:59.027

Reputation: 1 107

If I count correctly, that's 66 more bytes for the version with correct punctuation and grammar. I.e. an apple, 100 fishes, etc. and a dot at the end of each line. – Cœur – 2017-08-24T13:15:00.493

4

,,,, 14 bytes

"Hello, World!

I finally added unclosed strings to ,,,. Took me long enough.

totallyhuman

Posted 2015-08-28T12:23:59.027

Reputation: 13 394

4

ZT, 199 bytes

The ZT programming language is quite romantic: it features little data couples (Romeos & Juliets). ZT program flow is diagonal and commands are defined only by program flow.

The webpage is at:

It has a link to is an interpreter at:

But that interpreter is broken and doesn't do jumps correctly. The website also has a link to a self extracting archive containing the documentation, the interpreter and some examples:

And that interpreter works so that's the one you need to use to test this.

I am not too confident that this is the smallest possible Hello World but it is much smaller than the one published on the website. If you have comments for golfing it please let me know.

48<>ZT<>ZT<>...>
<<ZT<>ZT<>ZT.<06
ZT<>ZT<>6F<>6C<<
<<ZT<>ZT<>ZT><03
ZT<>ZT<>20<>72<<
<>ZT<>ZT<>ZT><05
...>65<>6F<>57<<
.>ZT<>ZT<>ZT><05
....64<>6C<>2C<<
....<>ZT<>ZT><05
........21>.6C<
........<...>

Jerry Jeremiah

Posted 2015-08-28T12:23:59.027

Reputation: 1 107

4

Numberwang, 77 bytes

69696969696969693696969623673363316969696968359533059595636969663633563583193

Try it online!

Just incrementing and decrementing the pointer by certain amounts.

Conor O'Brien

Posted 2015-08-28T12:23:59.027

Reputation: 25 859

4

Windows Portable Executable (PE), 1175 bytes

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

extern ExitProcess, GetStdHandle, WriteConsoleA

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

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

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

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

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

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

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

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


As a bonus, this executable also works on DOS.

Matheus Avellar

Posted 2015-08-28T12:23:59.027

Reputation: 263

4

ADJUST, 281 bytes

 ;I-      &  e$      &  m-        &  g2Ph$      &  a2$      &  n$      &  e2+-      &  g2Ph$      &  OPh$      &  m-      &  e-      &  n-
}     AgR};      AgR};      A=AgR};         AgR};       AgR};      AgR};        AgR};         AgR};        AgR};      AgR};      AgR};      AC

Try it online!

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

stasoid

Posted 2015-08-28T12:23:59.027

Reputation: 3 177

4

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.

DJMcMayhem

Posted 2015-08-28T12:23:59.027

Reputation: 37 405

Just finished the PPCG podcast this morning! Is there documentation available for Broccoli? – Esolanging Fruit – 2018-02-11T06:47:02.670

@EsolangingFruit I'm glad to hear it! :) There is a little bit of documentation in the folder, but it's pretty minimal. Mostly examples. But there is also a project to re-write it. You can ask for ask for help from the people there or in chat or on github.

– DJMcMayhem – 2018-02-11T07:12:11.817

4

095, 16 bytes

'Hello, World!'s

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

nosekill

Posted 2015-08-28T12:23:59.027

Reputation: 81

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

4

Prolog, 23 bytes

write('Hello, World!').

Fatalize

Posted 2015-08-28T12:23:59.027

Reputation: 24 736

What did you use to define a string if you didn't use "? – Beta Decay – 2015-08-28T12:57:50.563

1@BetaDecay Nothing, strings didn't exist as far as I know. So using " to create strings would create an array of character codes (ie ascii/unicode codes) representing the string. Character codes strings is created with backquotes in SWI-Prolog now. – Fatalize – 2015-08-28T13:01:17.377

You can use single quotes to turn this into an atom, and thus make the program completely portable: write('Hello, World!'). More declaratively, I would simply define a a fact like: msg('Hello, World!').. Usage example: ?- msg(M)., succeeding with M = 'Hello, World!'.. – mat – 2015-09-01T12:18:46.163

@mat Good suggestion that I use atoms instead of strings. For the msg('Hello, World!') though, I don't think it's valid in this challenge because it outputs M = 'Hello, World!'. instead of just Hello, World! (granted, it also outputs true after in my answer but I assume this is acceptable because Prolog really likes to output true or false :)) – Fatalize – 2015-09-01T12:25:11.360

I know, the way this challenge is formulated kind of forces you to use impure langauge elements. Too bad! (BTW: The last sentence of your post is no longer applicable.) – mat – 2015-09-01T12:27:36.260

4

PowerShell, 15 Bytes

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

"Hello, World!"

or, alternatively,

'Hello, World!'

In PowerShell, both ' and " denote string literals. The difference is the double-quotes will expand variables (e.g., $myString) and escape characters (e.g., `n), while the single-quote will treat everything literally.

PowerShell does an implicit Write of anything that's on a line by itself in a program (the relative merits of Write-Host vs Write-Output are left as an exercise to the reader) -- variable, literal string (as this is), result of a one-line command, etc. This stems from the fact that every line gets executed, and the way to execute a string is to print it. For other data types, if they have a way to convert to a string, the execution silently does the conversion in the background and then prints the resultant string. If there's no way to get a string, you'll wind up printing a description of the datatype. This is one of the ways that PowerShell, as ... verbose clear ... as it is, can wind up somewhat competing with other languages.

A short article on the topic, not written by me, though the author and I have a similar name.

AdmBorkBork

Posted 2015-08-28T12:23:59.027

Reputation: 21 590

4

Batch File, 19 Bytes

@echo Hello, World!

Short and to the point. You'd think you could golf off the @ at the beginning, but if you do you get the literal program echo'd out before the string is printed. This is why you'll see @echo off at the beginning of near every .bat file around.

Example without the @

C:\Tools\Scripts>.\hello-world.bat

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

AdmBorkBork

Posted 2015-08-28T12:23:59.027

Reputation: 21 590

Isn't the language itself just called "Batch"? – mbomb007 – 2015-08-28T13:54:38.630

1

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

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

If you leave off the the echo you get an infinite amount of hello world!'s – User112638726 – 2015-08-28T14:21:23.723

@User112638726 No, you should get something like 'Hello' is not recognized as an internal or external command, operable program or batch file. If you get something else, you must be using a different version of the interpreter than I am. – AdmBorkBork – 2015-08-28T14:28:03.157

@TimmyD It does that if i type directly into CMD but if it is run as a .bat it loops forever. Weird. – User112638726 – 2015-08-28T14:50:19.553

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

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

Well User112... gave me an idea. Rename your batch file to Hello.cmd and call it via Hello and you can shave off some extra bytes: @echo %0, World! 16 bytes – MrPaulch – 2015-08-29T11:33:42.073

2@MrPaulch if the filename is significant it has to be added to the byte coutn – undergroundmonorail – 2015-08-30T23:01:53.043

4

T-SQL, 20 bytes

print'Hello, World!'

Try it online

mbomb007

Posted 2015-08-28T12:23:59.027

Reputation: 16 876

4

Bash, 18 bytes

echo Hello, World!

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

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

4

Nim, 20 19 bytes

echo"Hello, World!"

Saved one byte thanks to sp3000!

kvill

Posted 2015-08-28T12:23:59.027

Reputation: 174

You can drop the space in between for the first one, I think :) – Sp3000 – 2015-08-28T15:09:14.370

Indeed, saved me one byte! – kvill – 2015-08-28T15:18:54.417

4

Emily, 22 bytes

println"Hello, World!"

This is a nice little language I stumbled upon recently.

refi64

Posted 2015-08-28T12:23:59.027

Reputation: 7 567

4

TI-BASIC, 22 bytes

"Hello, World!

Note that the lowercase letters are 2 bytes each.

TheNumberOne

Posted 2015-08-28T12:23:59.027

Reputation: 9 230

3I don't think the initial : is really part of the program, so I think this has a score of 22. – Ypnypn – 2015-08-28T16:06:45.993

@Ypnypn I'll take your word on it :) – TheNumberOne – 2015-08-28T18:45:47.507

4

Octave, 19 bytes

disp"Hello, World!"

Lynn

Posted 2015-08-28T12:23:59.027

Reputation: 41 980

4

D, 51 bytes

import std.stdio;void main(){puts="Hello, World!";}

In D, a=b is sometimes equivalent to a(b), allowing us to shave off one more byte than you might expect.

Lynn

Posted 2015-08-28T12:23:59.027

Reputation: 41 980

4

Q, 16 bytes

1"Hello, World!"

Just Y to go and we have the alphabet :)

Bit of a late update, but thanks to Mauris, we now have at least one language for every letter of the alphabet :D

Thanks @AaronDavies

Beta Decay

Posted 2015-08-28T12:23:59.027

Reputation: 11 590

1Not quite the requested output. I think you want 1"Hello, World!"; (doesn't include the trailing newline; to add one, change the 1 to a -1). Note, also valid for k. – Aaron Davies – 2015-08-29T23:19:55.637

4

PARI/GP, 22 bytes

print("Hello, World!")

alephalpha

Posted 2015-08-28T12:23:59.027

Reputation: 18 628

4

123, 282 267 bytes

22221121121112112222222211211112111211211222222221121121133121121312121122222222111211213
31211213122222222111211332113312112222221112112331123322222221111211111211222221111211211
22222222112111112112112112222222111112112112112222213312112131222222221121113321133121121

The newlines are only for cosmetic purposes. I'm fairly sure that this is not optimal.

Here is a slightly more readable (and also runnable) version:

H 22221121121112112
e 2222222112111121112112112
l 22222221121121133121121312
l 12112
o 22222221112112133121121312
, 2222222111211332113312112
  2222211121123311233
W 222222211112111112112
o 222211112112112
r 2222222112111112112112112
l 222222111112112112112
d 2222133121121312
! 2222222112111332113312112
1

I started out by constructing an optimal linear code (i.e. one which doesn't use 3s which allow for loop). That is quite simple: for each character, determine which bytes to flip from the last one. Move to the right-most character that has to be flipped (with a series of 2s), then move back to the left with 1 for each byte that has to be flipped and 121 for each byte that shouldn't be flipped. Finally move to the writing index -2 and print the character with 21. Repeat. At the very end, move to index -1 with a trailing 1 in order for the program to terminate.

This jumble of 1s and 2s was generated with this CJam script, which you can run online here:

0c"Hello, World!"+2ew::^{
_{2b8Ue[1a/W<1a*_,'2*'1@W%{'1"121"?}/"12"}{;"12112"}?
}/
'1

Then I removed some repetition of ones and twos by inserting loops by hand. 3 works as follows: if the instruction pointer is to the left of index 0, skip the 3. Otherwise, jump to the previous 3 if the current bit is 1 or jump ahead to the next 3 if the bit is 0. So simple loops, repeating a code segment x can be constructed as 33x33 or 33x3 (depending on whether the termination condition is "current bit is zero" or "moved to a negative index"). Then I started enumerating some relevant simple loops and when they are applicable. I've been using these loops only when moving back through the bits to change one character code to the next. If we can use a loop here depends both on the current state of a bit a and the target state b. I'll be denoting this combined state of each position as [a b]. Now here are the relevant loops and the required position patterns in a regex-like syntax:

121:    (^|[0 0]|[0 1]) ([1 1])+ [0 0]
112:    (^|[1 1]) ([0 0])+ ([0 1]|[1 1])
211:    ([0 0]|[0 1]) ([1 1])+ [0 0] ([0 0]|[1 1])
121121: ([0 0]|[0 1]) ([1 1] ([1 1]|[0 0]))+ [0 0]

Listing out the combined states for each character, we can annotate the potential loops and how many bytes they'll save (each ___ annotates the character above; sometimes multiple loops are possible):

H [[0 0] [0 1] [0 0] [0 0] [0 1] [0 0] [0 0] [0 0]]
e [[0 0] [1 1] [0 1] [0 0] [1 0] [0 1] [0 0] [0 1]]
l [[0 0] [1 1] [1 1] [0 0] [0 1] [1 1] [0 0] [1 0]]
        __________________121 -2
  ________________________121121 -3
l [[0 0] [1 1] [1 1] [0 0] [1 1] [1 1] [0 0] [0 0]]
o [[0 0] [1 1] [1 1] [0 0] [1 1] [1 1] [0 1] [0 1]]
        __________________121 -2
              __________________211 -2
  ________________________121121 -3
, [[0 0] [1 0] [1 1] [0 0] [1 1] [1 1] [1 0] [1 0]]
        ________________________211 -2
  [[0 0] [0 0] [1 1] [0 0] [1 0] [1 0] [0 0] [0 0]]
  ____________112 -2
W [[0 0] [0 1] [1 0] [0 1] [0 0] [0 1] [0 1] [0 1]]
o [[0 0] [1 1] [0 1] [1 0] [0 1] [1 1] [1 1] [1 1]]
r [[0 0] [1 1] [1 1] [0 1] [1 0] [1 0] [1 1] [1 0]]
l [[0 0] [1 1] [1 1] [1 0] [0 1] [0 1] [1 0] [0 0]]
d [[0 0] [1 1] [1 1] [0 0] [1 0] [1 1] [0 0] [0 0]]
        __________________121 -2
  ________________________121121 -3
! [[0 0] [1 0] [1 1] [0 0] [0 0] [1 0] [0 0] [0 1]]
        ________________________211 -2

Now I just picked the most profitable loop in each case and inserted it into the code.

I'm fairly certain that one could find a couple more loops that I've overlooked. But I also think that it's possible to find a significantly shorter solution that isn't based on anything a human would come up with. So far I have no idea how to efficiently search for such a solution automatically though, so I'll leave it at that for now.

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

4

4, 117 bytes

3.6000160103602136033260433605446067260787008070200908000120902111120111011015065095105105115055035075115125105085044

How it works

Generating characters with a code point below 100 is straightforward.

I've managed to create the others (derol) with three assignments and five additions/subtractions, which I believe is optimal.

3.            Begin the program.
  6 00 01     Set cell[ 0] to 1.
  6 01 03     Set cell[ 1] to 3.
  6 02 13     Set cell[ 2] to 13.
  6 03 32     Set cell[ 3] to 32 = ' '.
  6 04 33     Set cell[ 4] to 33 = '!'.
  6 05 44     Set cell[ 5] to 44 = ','.
  6 06 72     Set cell[ 6] to 72 = 'H'.
  6 07 87     Set cell[ 7] to 87 = 'W'.
  0 08 07 02  Set cell[ 8] to cell[ 7] + cell[2] =  87 + 13 = 100 = 'd'.
  0 09 08 00  Set cell[ 9] to cell[ 8] + cell[0] = 100 +  1 = 101 = 'e'.
  0 12 09 02  Set cell[12] to cell[ 9] + cell[2] = 101 + 13 = 114 = 'r'.
  1 11 12 01  Set cell[11] to cell[12] - cell[1] = 114 -  3 = 111 = 'o'.
  1 10 11 01  Set cell[10] to cell[11] + cell[1] = 111 -  3 = 108 = 'l'.
  5 06        Print cell[ 6] = 'H'.
  5 09        Print cell[ 9] = 'e'.
  5 10        Print cell[10] = 'l'.
  5 10        Print cell[10] = 'l'.
  5 11        Print cell[11] = 'o'.
  5 05        Print cell[ 5] = ','.
  5 03        Print cell[ 3] = ' '.
  5 07        Print cell[ 7] = 'W'.
  5 11        Print cell[11] = 'o'.
  5 12        Print cell[12] = 'r'.
  5 10        Print cell[10] = 'l'.
  5 08        Print cell[ 8] = 'd'.
  5 04        Print cell[ 4] = '!'.
4             End the program.

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

4

Var'aQ, 20 bytes

"Hello, World!" cha'

Var'aQ nIv rur Hol. 'oH rut lo' jIH ngaj-ghItlh.

Note: ghu'vam laH mugh jIH vaj DaneH'a'.

Beta Decay

Posted 2015-08-28T12:23:59.027

Reputation: 11 590

mughwI' vItu' 'oHbe' majQa'. – mbomb007 – 2015-09-01T14:48:23.397

@mbomb007 Qo', jIHvaD pIch, bing pIch – Beta Decay – 2015-09-01T14:51:21.240

What language is this? – LegionMammal978 – 2015-09-28T01:00:21.467

1@LegionMammal978 Klingon :) – Beta Decay – 2015-09-28T05:52:36.410

4

Deadfish~, 1 byte

w

Hooray for built-ins.

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

4

Beam, 312 161 bytes

'''''''''>`++++++++)@'''''''>`++++)+@+++++++@@+++@L'''''>`+++++++++)-@'''>`----)@'''''>`+++++++++++)@'''''>`+++++)-@+++@------@--------@'''''''>`---------)----@H

Try it online!

Beam is a 2D language similar to Befunge. Thanks to @MickyT for helping me golf it down.

Beam is based on several memory components:

  • The beam, the main integer value
  • The store, a secondary integer value
  • The memory, an array of integer storage

I've only used the beam and the store here.

Used commands:

  • + and - increment and decrement the beam by 1, respectively.
  • @ outputs the beam as an ASCII character.
  • ' and ` increment and decrement the store by 1, respectively.
  • ) sends the beam to the left if the store's value is not 0.
  • > sends the beam to the right. Combined with ), this is used here to make a loop.
  • L sets the beam to the store's value (0 in this case).
  • H halts the program. Not sure if this is necessary.

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

ETHproductions

Posted 2015-08-28T12:23:59.027

Reputation: 42 391

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 '''''&gt;\++++++++)` – MickyT – 2015-09-05T02:03:57.353

Using constants like that (assuming I got it right) reduces it to 136. Probably better ways to do this still. '''''&gt;``++++++++)@'''''''&gt;``++++)+@''&gt;``++)+@@+++@L''''''&gt;``----)@''&gt;``----)@''''''&gt;``-----)@'''&gt;``++++++++)@+++@------@''&gt;``---)@L''''''&gt;``+++)@ – MickyT – 2015-09-05T02:32:16.613

@MickyT There's no better way to get someone interested in an obscure esolang than to post an ungolfed solution in that language... ;) BTW, are all the double graves supposed to be single? – ETHproductions – 2015-09-05T15:10:43.570

@MickyT Actually, each of the graves will be run through twice in each loop (right at the beginning and right at the end), so there needs to be twice as many apostrophes beforehand. I'll update the post once I fix this. – ETHproductions – 2015-09-05T15:22:19.267

Oops, I miscounted the decrementers in the loop. Counted them once instead of twice on the turn around and I escaped them wrong when I posted to the comment. – MickyT – 2015-09-05T19:25:07.727

The H is, in fact, not neccessary. – Pavel – 2016-12-15T04:42:57.677

@Pavel You are correct. I removed the error for the beam leaving the source code when I ported it to TIO. Thanks :-) – ETHproductions – 2016-12-15T12:44:43.633

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

– Teal pelican – 2016-12-16T11:26:37.733

Scrap that! I used the memory store in a little better way (storing o) and re-used it a bunch to come up with this 141 bytes; Try it online!

– Teal pelican – 2016-12-16T11:37:29.240

@Tealpelican See also MickyT's 120 byte answer

– ETHproductions – 2016-12-25T21:11:53.350

4

Bubblegum, 11 bytes

0000000: 15 27 4d 50 62 a9 9a 29 6b 6d e2  .'MPb..)km.

Although technically Turing complete, Bubblegum was made for constant-output challenges.

Try it online!

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

4

Turing Machine Code, 132 bytes

As usual, I'm using the table syntax defined here.

0 * H r q
q * e r w
w * l r e
e * l r r
r * o r t
t * , r y
y * _ r u
u * W r i
i * o r o
o * r r p
p * l r a
a * d r s
s * ! r halt

If the above link isn't working (sometimes it works for me, other times the page refuses to load) you may also test this using this java implementation.

SuperJedi224

Posted 2015-08-28T12:23:59.027

Reputation: 9 433

4

HolyC, 24 bytes

Print("Hello, World!");

Nothing special here, I just wanted to pay tribute to the lunatic who wrote TempleOS and its companion language, HolyC.

dieter

Posted 2015-08-28T12:23:59.027

Reputation: 1 915

4

Gol><>, 16 bytes

"!dlroW ,olleH"H

Try it online.

I've really enjoyed golfing in ><>, but unfortunately I've found that ><> lacks several features, e.g. STDIN integer input, which prevent it from being competitive in challenges it otherwise would be. Gol><> is designed to (hopefully) be an easier-to-use variation of ><>. I worked on it earlier in the year, around when the language showcase was happening, but took a break and only picked it up again recently. It's starting to stabilise, so I thought it'd be a good time to post a first answer.

Similarly to ><>, " is a string parsing operator which pushes chars one at a time until it reaches a closing ". H then halts the program, outputting the stack until it is empty.

Even without H, Gol><> can still output the stack in a relatively short way. l pushes the length of the stack, o outputs a char from the stack and R pops a number n, repeating the next instruction n times. Thus, an equivalent program would be

"!dlroW ,olleH"lRo;

where ; terminates the program with no output.

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

Another solution would be S"Hello, World!". – LegionMammal978 – 2015-11-09T12:39:09.450

@LegionMammal978 Indeed :) (although you'll need a ; at the end or it'll print forever) – Sp3000 – 2015-11-09T12:43:25.380

4

Vitsy, 18 16 bytes

"!dlroW ,olleH"Z

"!dlroW ,olleH"     Push Hello, World! to the stack.
               Z    Push the entire stack to STDOUT - equivalent to l\O

Output:

Hello, World!

Z is new syntax - it was not made for this question.

Addison Crump

Posted 2015-08-28T12:23:59.027

Reputation: 8 084

4

Japt, 15 14 11 bytes

(using the ISO/IEC 8859 character encoding)

Japt is a shortened version of JavaScript. Interpreter

`HÁM, Wld!

There's an unprintable char in there, so here's a hexdump:

60 48 C1 4D 2C 20 57 8E 6C 64 21
`  H  Á  M  ,     W  .  l  d  !

Recently, @Vɪʜᴀɴ has helped me add in the shoco library for compressing strings. Using backticks around a string tells the interpreter to automatically decompress the string, and when a backtick is needed at the end of a program, you can leave it off. Thus, Japt now beats or ties all languages that don't have some sort of built-in to obtain "Hello, World!". (Including Pyth :D)

ETHproductions

Posted 2015-08-28T12:23:59.027

Reputation: 42 391

4

TeaScript, 12 bytes

(using ISO/IEC 8859 character encoding)

D`HÁM, Wld!

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

Downgoat

Posted 2015-08-28T12:23:59.027

Reputation: 20 837

This is 12 bytes, I think; there should be an unprintable in Wl. – ETHproductions – 2016-01-08T02:58:04.570

@ETHproductions you're right, whoops. I guess SE kills unprintables – Downgoat – 2016-01-08T02:58:55.863

2Perhaps a hexdump would be useful (via xxd or similar). – primo – 2016-01-08T04:25:03.240

4

Purple, 62 bytes

AA1AA1AA1bA1b1Bo1bb1bbibb1Bi1b     
 ! d l r o W   , o l l e H

Purple in a Nutshell:

Purple is a self-modifying language in the same sense that self-modifying brainfuck is: The code is executed from the same array that contains data, which is infinite and otherwise initialized with zeroes. It has one instruction with three arguments: subtract the third argument from the second and store it in the first. It has two registers, a and b, which can be dereferenced as A and B to get the contents of that memory address. It also has i, the instruction pointer, o which represents the outside world (i.e., stdout in the first argument, stdin in either of the other two), and the literal 1, which cannot be the first argument.

It is as hard to read and write as it looks.

This Program:

It may seem strange that I'm entering a program that is almost more not-code than code in a contest for "shortest program", but it would be REALLY DIFFICULT to do it in less. The reason is that, when doing loops in Purple, it requires the least effort to jump to memory location 3 (because you just set i to 0), but this means you have exactly one instruction to initialize the loop. This means we need to set A to the location of the first character to be printed in a single instruction. Otherwise, we'd have to do a lot of extra work to jump somewhere else at the end of each loop. But since a starts out at zero, the only positive value we can set it to in a single instruction is 64. (i.e. the contents of the zeroth cell--the "A" itself, which is ASCII 65, minus one.)

Obviously, we're going to want to iterate backwards over the string since

  • Iterating forwards means we have to put the string AFTER position 64, thereby making the program longer.
  • It takes one fewer instruction to decrement the pointer than to increment it.

And we can shave bytes off the end of the program by decrementing the pointer before we print. In fact, we have enough space between the cell 64 and the end of the program to decrement twice between each address to be printed. Thus, the first character we need to print can be at character 62, hence, exactly 62 bytes long.

Here's The Nitty:

AA1               Set the first cell to 64
AA1AA1            This is the entry point for the loop. M[0]=M[0]-2
bA1               Point b the cell to the left of what cell 0 points to.
b1B               Set b to one more than the opposite of the character there.
o1b               Output the character M[0] pointed to (one more than the opp. of b)
b1b               Set b to the just output character.
bib               Subtract the just output character from the IP (24)
                  Until we hit the newline (ascii 10), this yields a negative.
b1B               Set b to 1 minus what b was pointing to.
                  Negative addresses are initialized to zero, so until we hit the newline
                  this will set b to 1. When we hit the newline, b will be pointing to
                  the 11th character ("1"), and this will set it to -48.
i1b               Set the instruction pointer to 1-b. 
                  Until the newline, this sets i=0, jumping back the beginning of the loop.
                  After the newline, this sets i=49, where it finds the 
                  non-instruction "W  ", and Purple halts without error in such a case.

The rest of the program is the string itself and arbitrary padding to position the characters in the right place.

EDIT: Figured out how to save 30 bytes on this program, and updated all explanations to match the new version.

quintopia

Posted 2015-08-28T12:23:59.027

Reputation: 3 159

4

BTClang, 53 bytes

My newest invention! BTClang is short for Bitcoin language. Although it has nothing to do with bitcoins, it shares some similiarities with this language. Code:

4|$&2h
2|A%
3|Im!
3|%([F
2|!4P
2|"Cv
3|zJO
1|!M
2|!&r

Explanation:

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

ad5d3cc03d8b60e308b22e27fe4bbccae6a83d5496bc5e2a36aeb76eae51aeb0

The number before the pipe says how many hexadecimal number we want to extract from the end of the hash. This number is 2, so we take two 2-digit hexadecimal numbers from the end of the hash.

We are left with ae and b0. Converting these to integers will result into 174 and 176. These will be processed with the formula n % 94 + 32, so when this is converted to a character, the character will always be a printable ASCII character with 31 < ord < 128. The hashtags are replaced with newlines.

174 % 94 + 32 = 112 (p)
176 % 94 + 32 = 114 (r)

And so on...

The final translation of the code is print("Hello, World!"), which is then evaluated as normal Python. Although this is a solution, I am pretty sure this can be golfed further. It just takes a lot of computational power...

(By the way, you can try to find sets of characters yourself with the BTClang_miner)

Adnan

Posted 2015-08-28T12:23:59.027

Reputation: 33 457

How do you choose which hexadecimal numbers? – Conor O'Brien – 2016-04-08T00:32:54.433

1@CᴏɴᴏʀO'Bʀɪᴇɴ You mean from the hash? The numbers chosen are all taken from the end of the hash. So from ad5d3cc03d8b60e308b22e27fe4bbccae6a83d5496bc5e2a36aeb76eae51aeb0, the last two hexadecimal numbers are ae and b0. – Adnan – 2016-04-08T14:15:18.847

Oh, I'm an idiot. :| – Conor O'Brien – 2016-04-08T14:41:34.160

4

Scratch, 15 bytes

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

weatherman115

Posted 2015-08-28T12:23:59.027

Reputation: 525

Welcome to PPCG! – NoOneIsHere – 2016-05-20T15:23:53.530

You already welcomed me in Output the Current Time – weatherman115 – 2016-05-20T15:25:58.783

Sorry, the review link said you were new. – NoOneIsHere – 2016-05-20T15:35:29.757

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

– b_jonas – 2017-04-17T13:31:17.403

Well, this is awkward. – weatherman115 – 2017-04-17T18:06:38.710

4

68k machine code (EASy68k), 30 bytes

00000000: 303c 000d 43f9 0000 1010 4e4f ffff ffff  0<..C.....NO....
00000010: 4865 6c6c 6f2c 2057 6f72 6c64 2100       Hello, World!.

I don't know what I'm doing!

Explanation

    ORG    $1000
START:                  ; first instruction of program

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

    SIMHALT             ; halt simulator

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

    END    START        ; last line of source

user48538

Posted 2015-08-28T12:23:59.027

Reputation: 1 209

4

Your Mom, 14 bytes

'Hello, World!

Explanation

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

user48538

Posted 2015-08-28T12:23:59.027

Reputation: 1 209

4

Emojicode, 37 bytes

Hello, World!

betseg

Posted 2015-08-28T12:23:59.027

Reputation: 7 258

4

Golfuck, 39 bytes

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

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

acrolith

Posted 2015-08-28T12:23:59.027

Reputation: 3 040

4

V, 14 bytes

iHello, World!

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

Conor O'Brien

Posted 2015-08-28T12:23:59.027

Reputation: 25 859

4

Addict, 248 bytes

Addict is my new Turing-tarpit esolang, based on PRINDEAL.

a A
 i 1
 i 1
 d
a B
 A 1
 A 1
 d
a C
 B 1
 B 1
 d
a D
 C 1
 C 1
 d
a E
 D 1
 D 1
 d
E H
E H
C H
c H
E e
E e
E e
B e
i e
c e
E l
E l
E l
C l
B l
c l
c l
E o
E o
E o
D o
d o
c o
E c
C c
B c
c c
E s
c s
D H
d H
c H
c o
A o
i o
c o
c l
d e
c e
i s
c s

Test it online here!

Primer on addict

  • All memory is stored in variables. Variables can hold only non-negative integers; all variables start out at 0.
  • Addict has 4 built-in commands: decrement, increment, print a charcode, and take a charcode from input.
  • You can define your own commands with alias. This has very strict syntax:

a commandname
 command1
 command2
 command3

This creates a new command called commandname. Whenever commandname is called, the following process happens:

  • command1 is called.
  • If command1 succeeded, command2 is run.
  • If command1 failed, command3 is run.

See the GitHub repo for more information about Addict.


Act I

The first part of the program defines five commands: A, B, C, D, and E. Each one has this format:

a A
 i 1
 i 1
 d

This defines a command A which adds two to the input through the following process:

  • increment the 1st input.
  • If this succeeded, increment again. (i always succeeds unless it has no argument.)
  • Otherwise, decrement nothing. (This never gets run for the above reason.)

The next command defined is B, which adds 4 to the input:

a B
 A 1
 A 1
 d
  • Run A on the 1st input. (Always succeeds.)
  • If this succeeded, run A again. (Always gets run.)
  • Otherwise, decrement nothing. (Never gets run.)

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

Act II

The rest of the program is devoted to outputting Hello, World! in as few bytes as possible. The charcodes we need to output are 72 101 108 108 111 44 32 87 111 114 108 100 33, in that order. The shortest method I have found to output them all is to use six variables:

  • H to output 72 and 87
  • e to output 101 and 100
  • l to output 108
  • o to output 111 and 114
  • c to output 44
  • s to output 32 and 33

Here's a table of commands, and the values of the variables after each command:

Command  Output   H   e   l   o   c   s
E H              32   0   0   0   0   0
E H              64   0   0   0   0   0
C H              72   0   0   0   0   0
c H      H       72   0   0   0   0   0
E e              72  32   0   0   0   0
E e              72  64   0   0   0   0
E e              72  96   0   0   0   0
B e              72 100   0   0   0   0
i e              72 101   0   0   0   0
c e      e       72 101   0   0   0   0
E l              72 101  32   0   0   0
E l              72 101  64   0   0   0
E l              72 101  96   0   0   0
C l              72 101 104   0   0   0
B l              72 101 108   0   0   0
c l      l       72 101 108   0   0   0
c l      l       72 101 108   0   0   0
E o              72 101 108  32   0   0
E o              72 101 108  64   0   0
E o              72 101 108  96   0   0
D o              72 101 108 112   0   0
d o              72 101 108 111   0   0
c o      o       72 101 108 111   0   0
E c              72 101 108 111  32   0
C c              72 101 108 111  40   0
B c              72 101 108 111  44   0
c c      ,       72 101 108 111  44   0
E s              72 101 108 111  44  32
c s      (space) 72 101 108 111  44  32
D H              88 101 108 111  44  32
d H              87 101 108 111  44  32
c H      W       87 101 108 111  44  32
c o      o       87 101 108 111  44  32
A o              87 101 108 113  44  32
i o              87 101 108 114  44  32
c o      r       87 101 108 114  44  32
c l      l       87 101 108 114  44  32
d e              87 100 108 114  44  32
c e      d       87 100 108 114  44  32
i s              87 100 108 114  44  33
c s      !       87 100 108 114  44  33

If you can find any way to golf this program, please let me know!

ETHproductions

Posted 2015-08-28T12:23:59.027

Reputation: 42 391

Wow, this is a great language. Nice work! – Conor O'Brien – 2016-09-27T18:58:00.787

Seeing that 108, 111 and 114 are part of the output, maybe an alias to add 3 might help? – Martin Ender – 2016-09-27T18:58:27.720

@MartinEnder Thanks for the suggestion. An alias to add N will cost at least 17 bytes, so it'd need to save at least 5 lines (4 bytes each) to be worth it. (I originally had an alias F to add 64, but I only used it 4 times, so getting rid of it saved 1 byte.) – ETHproductions – 2016-09-27T19:01:36.347

@ConorO'Brien Thanks, I'm glad you like it! After spending a few months designing it, writing sample programs, and wishing I had time to code it, it took me about 4 hours to code: by far my shortest start-to-finish esolang implementation. ;) – ETHproductions – 2016-09-27T19:08:27.253

@Martin Using aliases for adding 2 3 6 12 24 48 seems to be about 7 bytes longer, but perhaps there's a different optimal set of aliases. I might write a brute-forcer when I have time. – ETHproductions – 2016-09-29T01:59:34.983

@ETHproductions Please publish it too, I wrote a longer program for the same thing before I discovered you had answered. – Erik the Outgolfer – 2016-10-21T14:07:51.237

3

Pushy, 16 bytes

`Hello, World!`"

Try it online!

The first thing to note is that Pushy has no string type. The backticks open/close "stringmode": every character in between has its codepoint (as an integer) pushed to the stack. The " is the print command, which takes all the stack's values, converts them to the corresponding chars, and prints the string.

In the very first version, before stringmode was implemented, program looked like this (can probably be golfed more):

72HhH8+&&3+44 32 87 111&3+&6-H33"

It basically just appends the necessary ASCII code points, then prints.

FlipTack

Posted 2015-08-28T12:23:59.027

Reputation: 8 743

3

DUP, 31 bytes

0$"Hello, World!"\[^^>][$;,1+]#

DUP is a descendant of FALSE, with FALSE being a subset of DUP in most aspects—with a few exceptions. One exception being the way strings are handled. See the FALSE solution in this thread for comparison. In DUP, strings cannot be ouput to STDOUT directly unless the characters are output one by one like this:

'H,'e,'l,'l,'o,',,' ,'W,'o,'r,'l,'d,'!,     (this solution would be 39 bytes long)

' pushes the Integer value of the following character on the data stack. , prints the character according to the integer value on the stack to STDOUT.

For shorter strings, this method is usually the shortest way, but in the case of Hello, World! this method is beyond the break even point of the actual string handling method of DUP.

0$"Hello, World!"\[^^>][$;,1+]#

This method successively assigns the characters between both double quotes " to addresses of a cell array, starting at a given address (in this case address 0).

In this case, the cells would carry the values

0=72 1=101 2=108 3=108 4=111 5=44 6=32 7=87 8=111 9=114 10=108 11=100 12=33 

After assigning the values to the cells, the length of the stored string gets pushed on the stack (in this case 13). The while loop [^^>][$;,1+]# at the end reads out the cell content, starting at 0, prints the according character to STDOUT, increments the counter, and repeats the procedure until the string length 13 is reached.

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

M L

Posted 2015-08-28T12:23:59.027

Reputation: 2 445

3

Whirl, 1350 bytes

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

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

Chance

Posted 2015-08-28T12:23:59.027

Reputation: 3 169

1350 bytes will easily fit into an answer. You should add the actual program to make it self-contained. – Dennis – 2017-01-12T01:30:01.593

Oops, thanks @Dennis . I'd intended to include it. – Chance – 2017-01-12T04:32:59.313

3

Threead, 16 bytes

"Hello, World!"o

Try it online!

Pavel

Posted 2015-08-28T12:23:59.027

Reputation: 4 211

Also works in Check.

– Esolanging Fruit – 2017-05-30T02:06:12.447

3

PUPPY, 369 bytes

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

The language that can only be read by puppies.

Josh

Posted 2015-08-28T12:23:59.027

Reputation: 617

3

;# 1142 bytes

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

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

; adds one to the accumulator

# outputs the accumulator mod 127

caird coinheringaahing

Posted 2015-08-28T12:23:59.027

Reputation: 6 705

isn't Turing Complete and doesn't meet the site's standard it does, since this is [tag:kolmogorov-complexity]. – Erik the Outgolfer – 2017-05-07T17:49:05.243

@EriktheOutgolfer yeah yeah, you know what I mean. – caird coinheringaahing – 2017-05-15T19:14:04.383

3

Ook!, 779 bytes

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

Based on the shortest Brainfuck Hello World :)

No one

Posted 2015-08-28T12:23:59.027

Reputation: 71

3

Folders (pure), 195 folders

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

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

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

Folders (concise), 2 folders + (5 + 13) bytes

./Setup
./Setup/Hello, World!

Eran W

Posted 2015-08-28T12:23:59.027

Reputation: 131

1Welcome to PPCG! / Using inline code formatting can be quite hard to read, I edited the answer. – user202729 – 2018-02-02T10:29:38.210

Does this include the comma? I don't see one in your concise version but I don't have a folders installation to check. – Potato44 – 2018-02-06T22:21:59.020

According to the original site, (and by the number of folders) it is with the comma. I fixed my concise example. – Eran W – 2018-02-07T00:44:15.863

3

Wumpus, 19 bytes

"!dlroW ,olleH"l&o@

Try it online!

Introducing the first 2D language on a triangular grid! (Unfortunately, you're not seeing much of that grid in this answer...)

Explanation

"!dlroW ,olleH"   Like in many other Fungeoids, this pushes the individual code
                  points of the string to the stack.
l                 Push the stack depth, 13.
&o                Print 13 characters.
@                 Terminate the program.

Martin Ender

Posted 2015-08-28T12:23:59.027

Reputation: 162 549

3

Forked, 42 bytes

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

Try it online!

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

3

AlphaBeta, 68 bytes

kjjjggDLeaCLcbbbCLLaaaCLjjjggDLjhhDLsFihhDLCLaaaCLdaaaaCLdaaCLsFiiDL

Try it online!

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

3

J, 15 bytes

'Hello, World!'

No call to any write function needed.

Fatalize

Posted 2015-08-28T12:23:59.027

Reputation: 24 736

3

Lua , 22 20 bytes

print"Hello, World!"

Thanks to @mathmandan for saving 2 bytes

jakebacker44

Posted 2015-08-28T12:23:59.027

Reputation: 41

1

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

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

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

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

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

@Socialz http://repl.it/BGIS

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

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

3

Actionscript 3.0, 23 22 bytes

trace("Hello, World!")

mbomb007

Posted 2015-08-28T12:23:59.027

Reputation: 16 876

Does actionscript 3.0 REQUIRE semi-colons? I stopped after 2.0 but I don't think it did back then. – Albert Renshaw – 2015-09-29T21:27:28.677

1@AlbertRenshaw is correct, it doesn't require a semi-colon in 3.0. – Elliot Blackburn – 2015-10-02T14:17:47.407

1@BlueHat Thanks guys. – mbomb007 – 2015-10-02T17:00:15.883

This works in the Actions pane of the Flash IDE, but Flash Builder or the Actionscript compiler, you need a full class definition. – Brian – 2016-01-15T18:54:34.600

3

unc, 38 bytes

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

refi64

Posted 2015-08-28T12:23:59.027

Reputation: 7 567

3

LOLCODE, 22 bytes

VISIBLE"Hello, World!"

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

Fatalize

Posted 2015-08-28T12:23:59.027

Reputation: 24 736

1Agh! Posted a minute before me :P – Kade – 2015-08-28T13:57:07.257

@Shebang Gotta go fast! – Fatalize – 2015-08-28T13:57:53.627

damn I'm a few days to late :( – Alex Carlsen – 2015-09-01T11:54:20.647

2And I pronounce this code, Ungolfable! – Erik the Outgolfer – 2016-06-04T13:01:25.560

3

Wheat, 32 Bytes

Wheat is an esolang that is based on outputting and inputting. Only what has been output on a previous cycle can be input on the current one. The buffers last only one cycle; if the data of previous cycle is not read on current cycle, on the next cycle it can not be accessed, it will all be erased, replaced by the output of the current cycle (if any, otherwise the empty string is used).

output "Hello, World!"
terminate

Kade

Posted 2015-08-28T12:23:59.027

Reputation: 6 148

The description of Wheat that you gave is taken directly from the Wheat esolang page. Care to cite? – Esolanging Fruit – 2018-01-21T06:41:14.270

3

Scala, 22 bytes

print("Hello, World!")

scala can run "scala scripts" which are not full program. you can save the above to a file and execute in the shell scala file.scala, and it will execute (shortcut without saving a file: scala -e 'print("Hello, World!")').

a full ordinary scala program that prints hello world:

object H extends App{print("Hello, World!")}

gilad hoch

Posted 2015-08-28T12:23:59.027

Reputation: 557

3

Gibberish, 17 Bytes

Surprisingly, the shortest answer I could make is not gibberish at all.

[Hello, World!]eo

Kade

Posted 2015-08-28T12:23:59.027

Reputation: 6 148

3

golflua, 16 bytes

w"Hello, World!"

manatwork

Posted 2015-08-28T12:23:59.027

Reputation: 15 670

3

Rust, 34 bytes

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

kvill

Posted 2015-08-28T12:23:59.027

Reputation: 174

3

Applescript, 15 bytes

"Hello, World!"

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

Digital Trauma

Posted 2015-08-28T12:23:59.027

Reputation: 55 069

1It's nice to see these verbose languages -- Applescript, PHP, PowerShell, etc. -- getting the better of lots of other languages for once. :) – AdmBorkBork – 2015-08-28T15:53:08.113

@TimmyD That doesn't mean that they are good languages. It's just that they are better at some things. – georgeunix – 2015-08-28T16:53:45.420

1@georgeunix Oh, without a doubt. Every language has its pluses and minuses. There are plenty of things I'd change about PowerShell, but there's nothing else I'd rather use to script and config Exchange. Even if it had commands and functionality to do so, I don't think I could use Pyth or CJam or whatnot on a day-to-day basis instead. I was just meaning "It's nice to see non-golfing languages toward the top of the lowest-byte-count list for a change." – AdmBorkBork – 2015-08-28T17:06:16.680

I understand @TimmyD – georgeunix – 2015-08-28T17:07:11.810

3

CJam, 15 bytes

"Hello, World!"

Try it online

aditsu

Posted 2015-08-28T12:23:59.027

Reputation: 20 689

3

XSM, 28 bytes

<print>Hello, World!</print>

Dennis

Posted 2015-08-28T12:23:59.027

Reputation: 171 923

This is an actual XML programming language? Wow. That's... different! – georgeunix – 2015-08-28T17:09:53.933

1Damn it, I was hoping I could write my own... Now someone's already gone and made it :P – Beta Decay – 2015-08-29T07:12:40.380

@BetaDecay There is also http://xplusplus.sourceforge.net/ and http://www.o-xml.org/

– Jerry Jeremiah – 2015-08-30T23:15:10.647

3

VBScript, 28 Bytes

WScript.Echo "Hello, World!"

This (should be) the shortest that prints to STDOUT (i.e., the command prompt window), when executed via command prompt wscript .\hello-world.vbs or cscript //nologo .\hello-world.vbs (the //nologo is necessary to prevent copyright info from being displayed). If you just double-click it, you'll get a pop-up message box instead, similar to the shorter example, below, at 22 bytes:

MsgBox "Hello, World!"

When executed, this second option will output a pop-up message box displaying the text inside the quotes. Since it's not technically STDOUT, and we do have a legitimate way to display STDOUT, we'll count the longer version instead.

AdmBorkBork

Posted 2015-08-28T12:23:59.027

Reputation: 21 590

3

GolfScript, 15 bytes

"Hello, World!"

aditsu

Posted 2015-08-28T12:23:59.027

Reputation: 20 689

3

Ook!, 949 Bytes

Just translated one of the Brainfuck answers here.

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

Rohcana

Posted 2015-08-28T12:23:59.027

Reputation: 200

1I always smile when I see this language. – AdmBorkBork – 2015-08-28T16:36:12.037

2This might be a case of "If your language of choice is a trivial variant of another (potentially more popular) language...". The shortest Ook! program will always be the translation of the shortest BF program (because each BF character is converted to the same length in Ook). So if Ook has a separate answer it needs to be updated every time someone finds a new shortest Brainfuck solution. (Ultimately, it's your call though if Ook should remain separate.) – Martin Ender – 2015-08-28T17:06:03.263

3I love reading the "Code" in a manner as if two people were talking to each other :) – MrPaulch – 2015-08-29T11:12:11.430

@MrPaulch I agree. The fact that first O is capitalized makes it sound like a fast Oh, okay with vocalized differences for punctuation in my mind. – mbomb007 – 2015-09-01T15:04:43.720

3

///, 13

Hello, World!

can't get much simpler than this

proud haskeller

Posted 2015-08-28T12:23:59.027

Reputation: 5 576

3

Vim, 17 bytes

iHello, World!{ESC}ZZ

Where {ESC} is a raw escape byte \x1b.

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

Lynn

Posted 2015-08-28T12:23:59.027

Reputation: 41 980

@LegionMammal978 the other seems to be Vimscript mislabelled as Vim. – primo – 2016-02-26T18:33:47.590

2I 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. – DJMcMayhem – 2016-06-29T17:33:25.903

Way longer and wrong output, but more interesting: :h_4&lt;CR&gt;/"H&lt;CR&gt;ly2wZZp – BlackCap – 2017-10-12T19:22:36.120

3

Go, 64 61 bytes

3 bytes thanks to George Gibson

package main
import."fmt"
func main(){Print("Hello, World!")}

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

isaacg

Posted 2015-08-28T12:23:59.027

Reputation: 33 634

package main;fund main(){print("Hello, world!")} – Eric Lagergren – 2015-09-06T16:53:00.370

1

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

– isaacg – 2015-09-06T22:04:32.890

Oh gotcha. Never looked it up because I never use it. Thanks. – Eric Lagergren – 2015-09-06T22:06:06.120

Save 3 bytes by importing fmt into the global namespace with import."fmt" then just call Print("Hello, World!"). – George Gibson – 2016-06-05T09:45:30.937

@GeorgeGibson Thanks, that's a nice trick. – isaacg – 2016-06-05T17:24:14.593

3

Underload, 16 bytes

(Hello, World!)S

Underload is the Brainfuck of stack-based languages. (x) pushes the string x to the stack, and S prints the value on top of the stack.

Lynn

Posted 2015-08-28T12:23:59.027

Reputation: 41 980

3

Rail, 27 bytes

$'main'
 -[Hello, World!]o#

Rail is a 2D language where the instruction pointer is a train that runs on, well, rails. Execution begins from the main function, starting from the $ and initially moving southeast.

The first command encountered is -, which makes the train turn so that it's moving eastward. Then we push a string, output with o and terminate with #.

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

3

bc, 16 bytes

"Hello, World!"

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

Digital Trauma

Posted 2015-08-28T12:23:59.027

Reputation: 55 069

3

Sinclair BASIC, 16 bytes

PRINT "Hello, World!"

Note: PRINT on the Sinclair Spectrum is written with a single keystroke (p) and takes a single byte. The code above works on the "command line".

You can try it online at http://torinak.com/qaop. Keystrokes for that emulator: p shift-' shift-h e l l o , space shift-w o r l d ctrl-1 shift-'. Don't press shift-1 as that seems to delete the whole line.

Depending on your definition of a "full program", this may or may not be acceptable. Especially for bigger programs, you would need to use line numbers, type the whole program and then use the RUN command (keystroke r). In that case, prepend a 1 to the above code (for 1 extra byte).

aditsu

Posted 2015-08-28T12:23:59.027

Reputation: 20 689

3

pb, 80 bytes

b[72]>b[101]>b[108]>b[108]>b[111]>b[44]>>b[87]>b[111]>b[114]>b[108]>b[100]>b[33]

Super naive. I tried to golf it down by keeping 108 (the character code for "l") in T, either by doing t[108] at the beginning of the program or t[B] after the first time it was printed, but each attempt ended up exactly the same length.

Note that pb doesn't require you to write b[32]. Any blank spaces on the canvas (with at least one non-blank space to the right of it) are automatically printed to the terminal as a space.

undergroundmonorail

Posted 2015-08-28T12:23:59.027

Reputation: 5 199

3

3var, 65 bytes

iiisa-<*>P/>is+iP>PPm-iiiPi<O/<m/>+<O+d<+<O+><kkkOP->siskkkOP</>P

Here's a 3var program found by brute force. Note that this might not be optimal since I assume that we'll only ever need numbers in the range 0-150, for efficiency reasons. I'll probably address this in a later edit.

3var is a Deadfish variant which has, well, three variables A, B and R. The relevant commands are:

Command              A           B           other
-----------------------------------------------------------
Increment            i           a
Decrement            d           k
Square               s           m
Output as char       P           O
Copy from R          >           <
Set R = A+B                                  +
Set R = A-B                                  -
Set R = A*B                                  *
Set R = A div B                              /

And here's a trace:

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

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

@LegionMammal978 Do you mean esolang wiki? The site seems fine to me... – Sp3000 – 2015-09-28T02:39:50.243

3

Tcl, 19 bytes

puts Hello,\ World!

I think this can get smaller than it already is.

Johannes Kuhn

Posted 2015-08-28T12:23:59.027

Reputation: 6 582

Is that missing the comma? – curiousdannii – 2015-08-29T13:00:18.297

What comma do you mean? – Johannes Kuhn – 2015-08-29T13:06:51.197

I'm just guessing, but will this print "Hello World!" rather than "Hello, World!"? – curiousdannii – 2015-08-29T13:10:24.630

Right... Forgot that piece... – Johannes Kuhn – 2015-08-29T13:12:29.207

3

Dogescript, 42 37 bytes

plz console.loge with "Hello, World!"

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

LegionMammal978

Posted 2015-08-28T12:23:59.027

Reputation: 14 318

plz console.loge with "Hello, World!"is shorter, but admittedly less wow – kvill – 2015-08-31T15:21:54.123

1Is the plz necessary? I thought you could just console.loge. – Alex A. – 2015-09-02T05:59:32.993

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

– kvill – 2015-09-02T19:56:29.867

That's what I was thinking... – LegionMammal978 – 2015-09-03T10:57:31.560

3

KEMURI, 65 bytes

`^^^^"^^'"'^'"'"^^`^^'^''^"^^^^^^''^'"''"^^`^^^^^'"^^'^'^''^'^'^|

There's a KEMURI to C compiler available here if you'd like to test.

KEMURI is stack-based, and has the following 6 instructions:

~    Pop byte and push its NOT
^    Pop two bytes and push their XOR
"    Duplicate top of stack
'    Rotate top three of stack (top becomes third)
`    Push the ASCII values of "Hello, world!"
|    Output stack as ASCII

Note that ` pushes "Hello, world!" with a lowercase w. This means that the shortest "Hello, world!" program is

`|

but that doesn't mean that the best "Hello, World!" program, with an uppercase w, will be particularly short.

To aid our search for the best "Hello, World!", here are a couple of observations:

  • | empties the stack, so we will only need it exactly once, as the very last character in the program.
  • ~ is useless, since NOT will flip the most significant bit to 1, which no printable ASCII character needs.
  • We will never need to duplicate with " if the top two stack elements are the same, since:
    • Rotating three identical elements is a no-op.
    • The only way to reduce the stack size is with ^ XOR. XOR of two identical elements just introduces a 0 and XOR 0 is a no-op.
    • "Hello, World!" contains neither a triple letter nor ASCII 0.

This means that we only need to look at the four instructions ^"'`. To piece together the "Hello, World!", I looked at programs which contain a single `, at the very start. This gives a bunch of "jigsaw pieces" which we can fit together to form the whole message. There's no guarantee that this approach is optimal, but the search space is pretty big, so any better solution will probably need to be a bit more intelligent.

The pieces I managed to obtain were (<sp> is trailing space):

World!   `^^^^^"^^^|
orld!    `^^^^^^^"^^|
rld!     `^^^^^^^^"^^|
ld!      `^^^^^^^^^"^^|
d!       `"^^^^^^^^^^^^|
World!   `^^^^^"^'"'^'^|
<sp>     `^"^^^^^^^^^^^^|
!        `^^^^^^^^^^^"^^|
H        `^^^^^^^^^^'^"^^|
,        `^^^^^^^^^^''"^^^|
d        `^^^^^^^^^^''^"^^|
o        `^^^^''^"^^^^^^^^|
e        `"^^^^^^'"^^^^^^^^|
W        `^"^^^^^^'"^^^^^^^|
l        `^^"^^^^'"^^^^^^^^|
, World! `^^^^"^^'"'^'"'"^^|
ld       `^^^^^^^^^"^^''"^^|
ll       `^^"^^^^'"^^^^^^^^"|
r        `^^^^^^'"^^^^'^"^^^|
rl       `^^^^^^'"^^^^''"^^''^|
He       `^^^^^'"^^'^'^''^'^'^|
el       `^^"^^^^^^^^''"^^''"^^|
o,       `^^'^"^^^^"'^'^'^'^'^'^|
Wo       `^^^^"^^^'"^^'^''^''^''^|
,<sp>    `^^^^^'^'^'^''^''^'"'^'^|
lo       `^^^^^^^"^^'"^^''"^^''"^^|
or       `^^^^^^'^"^^''"^^''"^^''^|
llo      `^^'^''^"^^^^^^''^'"''"^^|
ell      `^^"^^^^^^^^''"^^'"''"^^''|
 W       `^"^^^^^^''^''^''^''^''^"'^|

The program at the top of the post was formed by combining the He, llo and , World! pieces.

Sp3000

Posted 2015-08-28T12:23:59.027

Reputation: 54 224

3

Aheui, 177 bytes

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

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

Lynn

Posted 2015-08-28T12:23:59.027

Reputation: 41 980

3

Piet, 132 codels

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

Piet code

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

Made and tested on PietDev.

plannapus

Posted 2015-08-28T12:23:59.027

Reputation: 8 020

3

MicroSoft Windows HTA - 13 bytes

Hello, World!

MicroSoft Windows HTA occupies a niche between HTML and applications, where you get the simplicity and ease of HTML, with the direct access to the system API of applications, including file and system calls.

When I was first introduced to it, I wondered how I ever got along without it. I used it to make really easy intuitive interfaces for complex command line utilities.

Sadly, it's fallen by the wayside and you hardly hear about it anymore. One thing I remember about the official documentation was that they boasted how a bare Hello, World! is a legal hypertext application.

Yimin Rong

Posted 2015-08-28T12:23:59.027

Reputation: 6 663

3

Swift, 22 Bytes

Before Version 2.0 (24 Bytes)

println("Hello, World!")

After Version 2.0 (22 Bytes)

print("Hello, World!")

Includes trailing newline

Top level code in the main file gets executed automatically. In playgrounds, anything at top level gets executed as well.

In version 2.0 beta 6 this is also possible:

print("Hello,", "World!")

which will print all the items provided, separated by a space, terminated by a newline. This is equal to the following (which is probably the longest Swift version of a non-ridiculous "Hello, World!" program):

print("Hello,", "World!", separator: " ", terminator: "\n")

Since version 2.0 beta 6, Swift is one of the few languages that can have a vararg parameter at any position (not just the end), due to named parameters.

Kametrixom

Posted 2015-08-28T12:23:59.027

Reputation: 381

3

Beam, 128 120 Bytes

'''''''''>`++++++++)@'''P''''>`++++)+@+++++++@P@+++@'P'L'''>`++++++)''P'>`++++)@''p@'p>`+++++)@'p@+++@`p@--------@''p+@H

This uses the general construct:

'''''''''              # increment store to 9
         >             # set direction right. Beginning of loop
          `            # decrement store
           ++++++++    # increment beam 8 
                   )   # set direction left if store not 0. End of loop
                    @  # Output character

Effectively translates to 9 * 8. The store needs to be odd before entering the loop otherwise it will end up being an infinite loop. The Esolangs has examples of this at the bottom in the constants section.

P is used to save to l, o and memory slots 0, 1 and 2.
p is used to retrieves those values to the beam.

The following snippet should run Beam programs, but it hasn't been put through the ringer yet, so is likely to have some bugs.

var ITERS_PER_SEC = 100000;
var TIMEOUT_SECS = 50;
var ERROR_INTERRUPT = "Interrupted by user";
var ERROR_TIMEOUT = "Maximum iterations exceeded";
var ERROR_LOSTINSPACE = "Beam is lost in space";

var code, store, beam, ip_x, ip_y, dir, input_ptr, mem;
var input, timeout, width, iterations, running;

function clear_output() {
document.getElementById("output").value = "";
document.getElementById("stderr").innerHTML = "";
}

function stop() {
running = false;
document.getElementById("run").disabled = false;
document.getElementById("stop").disabled = true;
document.getElementById("clear").disabled = false;
document.getElementById("timeout").disabled = false;
}

function interrupt() {
error(ERROR_INTERRUPT);
}

function error(msg) {
document.getElementById("stderr").innerHTML = msg;
stop();
}

function run() {
clear_output();
document.getElementById("run").disabled = true;
document.getElementById("stop").disabled = false;
document.getElementById("clear").disabled = true;
document.getElementById("input").disabled = false;
document.getElementById("timeout").disabled = false;

code = document.getElementById("code").value;
input = document.getElementById("input").value;
timeout = document.getElementById("timeout").checked;
 
code = code.split("\n");
width = 0;
for (var i = 0; i < code.length; ++i){
 if (code[i].length > width){ 
  width = code[i].length;
 }
}
console.log(code);
console.log(width);
 
running = true;
dir = 0;
ip_x = 0;
ip_y = 0;
input_ptr = 0;
beam = 0;
store = 0;
mem = [];
 
input = input.split("").map(function (s) {
  return s.charCodeAt(0);
 });
 
iterations = 0;

beam_iter();
}

function beam_iter() {
while (running) {
 var inst; 
 try {
  inst = code[ip_y][ip_x];
 }
 catch(err) {
  inst = "";
 }
 switch (inst) {
  case ">":
   dir = 0;
   break;
  case "<":
   dir = 1;
   break;
  case "^":
   dir = 2;
   break;
  case "v":
   dir = 3;
   break;
  case "+":
   ++beam;
   break;
  case "-":
   --beam;
   break;
  case "@":
   document.getElementById("output").value += String.fromCharCode(beam);
   break;
  case ":":
   document.getElementById("output").value += beam+"\n";
   break;
  case "/":
   switch (dir) {
    case 0:
     dir = 2;
     break;
    case 1:
     dir = 3;
     break;
    case 2:
     dir = 0;
     break;
    case 3:
     dir = 1;
     break;
   }
  case "\\":
   switch (dir) {
    case 0:
     dir = 3;
     break;
    case 1:
     dir = 2;
     break;
    case 2:
     dir = 1;
     break;
    case 3:
     dir = 0;
     break;
   }
   break;
  case "!":
   if (beam != 0) {
    switch (dir) {
    case 0:
     dir = 1;
     break;
    case 1:
     dir = 0;
     break;
    case 2:
     dir = 3;
     break;
    case 3:
     dir = 2;
     break;
    }
   }
   break;
  case "?":
   if (beam == 0) {
    switch (dir) {
    case 0:
     dir = 1;
     break;
    case 1:
     dir = 0;
     break;
    case 2:
     dir = 3;
     break;
    case 3:
     dir = 2;
     break;
    }
   }
   break;
  case "|":
   switch (dir) {
   case 0:
    dir = 1;
    break;
   case 1:
    dir = 0;
    break;
   }
   break;
  case "_":
   switch (dir) {
   case 0:
    dir = 1;
    break;
   case 1:
    dir = 0;
    break;
   }
   break;
  case "H":
   stop();
   break;
  case "S":
   store = beam;
   break;
  case "L":
   beam = store;
   break;
  case "s":
   mem[beam] = store;
   break;
  case "g":
   store = mem[beam];
   break;
  case "P":
   mem[store] = beam;
   break;
  case "p":
   beam = mem[store];
   break;
  case "u":
   if (beam != store) {
    dir = 2;
   }
   break;
  case "n":
   if (beam != store) {
    dir = 3;
   }
   break;
  case "`":
   --store;
   break;
  case "'":
   ++store;
   break;
  case ")":
   if (store != 0) {
    dir = 1;
   }
   break;
  case "(":
   if (store != 0) {
    dir = 0;
   }
   break;
  case "r":
   if (input_ptr >= input.length) {
    beam = 0;
   } else
   {
    beam = input[input_ptr];
    ++input_ptr;
   }
   break;
  }
 // Move instruction pointer
 switch (dir) {
  case 0:
   ip_x++;
   break;
  case 1:
   ip_x--;
   break;
  case 2:
   ip_y--;
   break;
  case 3:
   ip_y++;
   break;
 }
 if (running && (ip_x < 0 || ip_y < 0 || ip_x >= width || ip_y >= code.length)) {
  error(ERROR_LOSTINSPACE);
 }
 ++iterations;
 if (iterations > ITERS_PER_SEC * TIMEOUT_SECS) {
  error(ERROR_TIMEOUT);
 }
}
}
<div style="font-size:12px;font-family:Verdana, Geneva, sans-serif;">Code:
    <br>
    <textarea id="code" rows="3" style="overflow:scroll;overflow-x:hidden;width:90%;">'''''''''>`++++++++)@'''P''''>`++++)+@+++++++@P@+++@'P'L'''>`++++++)''P'>`++++)@''p@'p>`+++++)@'p@+++@`p@--------@''p+@H</textarea>
    <br>Input:
    <br>
    <textarea id="input" rows="2" style="overflow:scroll;overflow-x:hidden;width:90%;"></textarea>
    <p>Timeout:
        <input id="timeout" type="checkbox" checked="checked">&nbsp;
        <br>
        <br>
        <input id="run" type="button" value="Run" onclick="run()">
        <input id="stop" type="button" value="Stop" onclick="interrupt()" disabled="disabled">
        <input id="clear" type="button" value="Clear" onclick="clear_output()">&nbsp; <span id="stderr" style="color:red"></span>
    </p>Output:
    <br>
    <textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea>
</div>

MickyT

Posted 2015-08-28T12:23:59.027

Reputation: 9 062

3

Commodore Basic, 16 bytes

In order to input this program, you'll need to switch your Commodore 64 to character set 2 by pressing <SHIFT> + <C=>.

1?"hELLO wORLD!

The Commodore home computers come with two character sets: "unshifted" mode, which is derived from ASCII-1963 and so lacks lower-case letters, and "shifted" mode, which has both lower- and upper-case letters, but in the opposite order from modern ASCII-1967-derived encodings. Any "Hello, World!' program that produces the requested byte stream on a Commodore will look funny on the Commodore's screen. In the interests of not having to look up a half-dozen obscure Unicode characters, I've chosen to write my program in "shifted" mode, which merely has reversed case.

As a side note, the Commmodore Basic interpreter (and presumably many other Microsoft Basic variants) will let you omit the trailing quotation mark if a string extends to the end of the current source line.

Mark

Posted 2015-08-28T12:23:59.027

Reputation: 1 896

3

Simplex, 16 bytes

"Hello, World!"g

g is the standard output mechanism.

LegionMammal978

Posted 2015-08-28T12:23:59.027

Reputation: 14 318

1Thanks for using Simplex :D – Conor O'Brien – 2015-10-26T11:21:15.987

3

Acc!!, 122 bytes

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

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

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

Works the same in Acc!.

DLosc

Posted 2015-08-28T12:23:59.027

Reputation: 17 064

@quartata Thanks for the edit, but italics in the language name breaks the scoreboard. – DLosc – 2016-01-20T22:56:05.510

Ah. Sorry, didn't realize :P – quartata – 2016-01-20T23:45:14.360

Maybe the scoreboard snippet should be updated. – mbomb007 – 2016-01-22T17:58:24.297

3

BitShift, 216 211 209 bytes

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

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

10111110111110101001011001001010111011111010011010100101011001000100101011001000001100101011111110011010100101100110010001000100101011110100110110101001000010001010110111101110111101010001000010101111101101010

You can test it here.

Bassdrop Cumberwubwubwub

Posted 2015-08-28T12:23:59.027

Reputation: 3 873

3

PlatyPar, 14 bytes

"Hello, World!

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

Try it here!

Cyoce

Posted 2015-08-28T12:23:59.027

Reputation: 2 273

3

pl, 13 bytes

Hello, World!

Yes, it works. Try it online.

Explanation

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

quartata

Posted 2015-08-28T12:23:59.027

Reputation: 8 270

3

Whenever, 25 bytes

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

1 print("Hello, World!");

Jerry Jeremiah

Posted 2015-08-28T12:23:59.027

Reputation: 1 107

3

Fuzzy Octo Guacamole, 15 bytes

"Hello, World!"

This is a new language I created with inspiration from @Conor's NTFJ, @MatinBüttner's Brian and Chuck, and a couple others.

It has 2 stacks.

This is fairly simple and only uses one stack though.

The "..." denotes a string literal that is pushed to the stack.

Then implicit output.

Riker

Posted 2015-08-28T12:23:59.027

Reputation: 5 743

3

VHDL, 98 bytes

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

At least it's not Java...

Justin

Posted 2015-08-28T12:23:59.027

Reputation: 17 266

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

3

Y 16 bytes

No, not http://foldoc.org/Y or https://github.com/ConorOBrien-Foxx/Y although we probably need an entry for both of them as well...

Y is a stack-oriented FORTH-type programming language by Thomas Fischbacher derived from Wouter van Oortmerssen's "FALSE". Like FALSE, Y is cryptic to the extreme. According to the readme it is much more powerful because "virtually all of the example programs in 'Kernighan & Ritchie - Programming in C' can be done in Y in a fraction of time and code."

"Hello, World!"`

Jerry Jeremiah

Posted 2015-08-28T12:23:59.027

Reputation: 1 107

3

Kotlin, 50 48 bytes

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

Rames

Posted 2015-08-28T12:23:59.027

Reputation: 221

3

Pyramid, 587 294 bytes

(72)[
no
+<
]
=
a
<
=
np
<
=
(29)[
no
+<
]
=
a
<
=
np
+<
=
a
++++++<
=
np
<
=
a
<
=
np
+<
=
a
++<
=
np
<
=
(67)[
no
-<
]
=
a
<
=
np
-<
=
a
-----------<
=
np
<
=
(55)[
no
+<
]
=
a
<
=
np
<
=
(24)[
no
+<
]
=
a
<
=
np
<
=
a
+++<
=
np
<
=
a
------<
=
np
<
=
a
--------<
=
np
<
=
(67)[
no
-<
]
=
a
<

Yikes... this is a monstrosity. This is now less of a monstrosity, but still crazy big for "Hello, World!".

The new byte count was because for-loops were implemented in Pyramid (YES!)

Pyramid is a stack-based language, which was built on Stackylogic. You should probably go and click on the link before you go to the Github page, because you'll understand the what the commands mean on the GH page better.

There's 250 104 lines of code here, if you're interested.

Qwerp-Derp

Posted 2015-08-28T12:23:59.027

Reputation: 3 815

link 404 why :(? – Destructible Lemon – 2016-09-23T03:09:16.370

@DestructibleWatermelon Oh yeah, that's because I stopped working on Pyramid. – Qwerp-Derp – 2016-09-23T06:40:36.847

3

Codelike, 127 bytes

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

Try it!

Connor D

Posted 2015-08-28T12:23:59.027

Reputation: 81

2

TI-83 Hex Assembly, 21 bytes

PROGRAM:H
:AsmPrgm219C9DEF0A45C9
:48656C6C6F2C20576F726C642100

Run it with Asm(prgmH). First line is code section, 2nd line is data section. I count each pair of hex digits as one byte.

Harry

Posted 2015-08-28T12:23:59.027

Reputation: 620

2

*><>, 21 bytes

"!dlrow ,olleH"Ool?u;

Try it out on the online interpreter here.

*><> (pronounced "Starfish") is an esolang based on ><>, developed by redstarcoder. Its aim is to add some useful features which are missing from base ><>, such as file IO, time functionality, and an interesting feature called 'dive/rise', which is used here.

If the 'dive' command, u is encountered, no instructions other than directional modifiers are executed until a 'rise' command, O, is encountered. Encountering a dive whilst already diving, or a rise when not diving, is treated as a no-op.

"!dlrow ,olleH"Ool?u;   

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

Sok

Posted 2015-08-28T12:23:59.027

Reputation: 2 171

I love ><> and been interested in *><> so using the dive command for a huge benefit which I haven't seen before is great :) – Teal pelican – 2016-12-19T14:47:37.093

2

stacked, 18 bytes

'Hello, World!'out

Try it here!

Introducing my newest creation, stacked! It's a stack based language. Creative, I know. But this pushes 'Hello, World!' to the stack the outputs it. Simple enough!

Conor O'Brien

Posted 2015-08-28T12:23:59.027

Reputation: 25 859

2

WSF, 223 bytes

Stack Exchange cannot display this code properly, so here is a reversible xxd hexdump:

00000000: 2020 2020 2020 2020 2020 2020 2020 2020                  
00000010: 2020 2020 0a20 200a 2020 2020 2020 2020      .  .        
00000020: 2020 2020 2020 200a 2020 2020 2020 2020         .        
00000030: 2020 2020 2020 2020 2020 2020 200a 2020               .  
00000040: 2020 2020 200a 2020 0920 0920 0920 0920       .  . . . . 
00000050: 2009 0a09 200a 2020 2020 0909 200a 2020   ... .    .. .  
00000060: 0909 2020 2020 2020 2020 2020 2020 2020  ..              
00000070: 0909 0909 2020 2020 2020 0909 200a 2020  ....      .. .  
00000080: 2020 0909 0920 0920 2020 2020 2020 2020    ... .         
00000090: 2020 2020 2020 2020 2020 2020 2020 2020                  
000000a0: 2020 2020 2020 0909 200a 0909 2020 2020        .. ...    
000000b0: 2020 0909 2009 2009 2009 2009 2009 2009    .. . . . . . .
000000c0: 0909 2009 2009 2009 2009 2009 2009 2009  .. . . . . . . .
000000d0: 2009 0909 200a 2020 0909 200a 0909 0a     ... .  .. ....

Ruby inspected string:

"                    \n  \n               \n                     \n       \n  \t \t \t \t  \t\n\t \n    \t\t \n  \t\t              \t\t\t\t      \t\t \n    \t\t\t \t                               \t\t \n\t\t      \t\t \t \t \t \t \t \t\t\t \t \t \t \t \t \t \t \t\t\t \n  \t\t \n\t\t\n"

Mendeleev

Posted 2015-08-28T12:23:59.027

Reputation: 2 754

There's a 174 byte one on TIO – ASCII-only – 2017-08-21T12:16:28.950

2

Befunge-93, 21 bytes

"!dlroW ,olleH">:#,_@

Try it online!

Explanation

"!dlroW ,olleH"   Push the string onto the stack in reverse. Note that there is an
                    implicit null terminator since an empty stack will always pop zero.

>                 Start the output loop.
 :                Duplicate the character at the top of the stack.
  #               Skip the following operation to the right.    
    _             Test if the character is null, dropping the duplicate copy.
   ,              If not, branch left and write the character to stdout.
  #               Skip the following operation to the left.
>                 Reverse direction and repeat the loop with the next character.
     @            Once the null is reached, branch right and exit.

James Holderness

Posted 2015-08-28T12:23:59.027

Reputation: 7 362

2

Del|m|t, 29 + 1 = 30 bytes

Try it online!

=#:#Hello, World!#/#2#>#?#9#"

...With # passed as a command line argument.

This is a new language that I recently created, which uses regex to parse its source code. I highly recommend that you read the documentation and tutorial.

Explanation:

The regex passed as an argument acts as a delimiter (hence the name), which parses the code into tokens, which are read as commands based on their ASCII values.

Because the regex is #, the tokens are =, :, Hello, World!, /, 2, >, ?, 9, and "

These correspond to commands depending on their ASCII values mod 32:

(=) 29    29 pops the top value of the stack, and skips that many instructions.
          Right now, the top is 0, so it's a no-op. Later, we will use it to
          skip the following part that pushes the string

(:) 26, (H...) "H..."    26 pushes the next token as a string backwards onto the stack

(/) 15    Duplicates the top of the stack, so we have 2 copies of the top character.
(2) 18    Nots the top of the stack. It the top was 0, it is now 1

(>) 30, (?) 31    Iff the top of the stack is non-0, exit the program

(9) 25    Print the character
(") 2     Push 2 - This is used to skip the String pushing part when we...

          Go back to the start of the program and repeat

Mistah Figgins

Posted 2015-08-28T12:23:59.027

Reputation: 2 362

2

SmileBASIC, 15 bytes

?"Hello, World!

? is a shorthand for PRINT, which is of course always at least 4 characters shorter and never needs whitespace before or after it. In addition, strings which run to the end of the line don't need the closing ".

snail_

Posted 2015-08-28T12:23:59.027

Reputation: 989

It's supposed to print an uppercase W (even though it's in the middle of the sentence...) – 12Me21 – 2017-02-01T20:49:28.467

2

Taxi, 184 bytes

"Hello, World!" is waiting at Writer's Depot.Go to Writer's Depot:w 1 r 3 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:e 1 r 2 r 1 l.Go to Taxi Garage:n 1 r 1 l 1 r.

Try it online!

Erik the Outgolfer

Posted 2015-08-28T12:23:59.027

Reputation: 25 165

When golfing in Taxi, is it strictly necessary to return to the garage after the post office? Officially, the program isn't successful unless you end in the garage but it still prints on Tio Nexus. I don't know what happens using the C++ interpreter from github. If it's not required, dropping it saves 32 bytes. – Engineer Toast – 2017-03-22T19:28:56.550

@EngineerToast The challenge specification specifically says there can't be any STDERR output, while if you don't return to the garage, it says something along the lines of being fired from your position as a taxi driver because you didn't return the car at the garage. Try removing Go to Taxi Garage.... and then click on "Debug" to open STDERR output + TIO debug output, then run the program. – Erik the Outgolfer – 2017-03-23T12:43:59.900

Ah, good point; I overlooked that. Thank you for explaining it so completely for the novice that is me. It's something I plan to use in other Taxi golfing, though, bolstered by a meta post that discusses it.

– Engineer Toast – 2017-03-23T22:47:59.383

You can remove the space after the quote – ASCII-only – 2017-08-23T06:55:54.933

2

Valyrio, 17 bytes

s ∫ main [´Ø]

and start and end comments.

s ‹Sets the mode to stack mode, usually used for code golf as its shorter›
∫ ‹Tells the interpreter that the previous letter was a tag, not a command›
main [ ‹Starts the main code block›
´ ‹Pushes "Hello, World!" in unicode numbers to the stack (Alt-Shift-E on Mac)›
Ø ‹Outputs the stack as unicode characters›
] ‹Ends the main code block‹

user63571

Posted 2015-08-28T12:23:59.027

Reputation:

2Nope. It's 17 bytes. – TuxCopter – 2017-02-04T22:43:50.537

2No, not 13 bytes. 17 bytes. The interpreter recieves a file as UTF-8 bytes, of which there are 17, it doesn't matter how it tokenises those bytes. This is opposed to, e.g. TI-Basic which has a character encoding that really does represent multiple characters with one bytes. – Pavel – 2017-02-04T22:44:05.313

Oh. Didn't realise it worked that way, I'll change it. – None – 2017-02-04T22:44:47.667

Also why downvote simply because I didn't understand string encoding? Seems a little mean. – None – 2017-02-04T22:47:23.040

@JackBates reading the readme on GitHub, I noticed that Valyrio includes a "code-golf" mode, in which every builtin is a byte. How does that work? – Pavel – 2017-02-04T23:11:27.020

That was in the above confusion. I'll remove it from the code – None – 2017-02-04T23:12:36.563

Is there a 6-byte file you can pass to the interpreter to print Hello World? If there is, you can claim a score of 6 bytes. – Dennis – 2017-02-04T23:38:42.500

Not in UTF-8 but I'm not sure about other encodings. s ∫ main [ is needed to prefix all stack mode languages so... – None – 2017-02-04T23:41:28.547

2

Commodore 64/128/VIC-20 & others (BASIC) (21 bytes 20 bytes):

0 PRINT"HELLO, WORLD!

Commodore 64/VIC-20 (assembly) using the Kernal** (27 bytes assembled):

*=$033c
ldx #$00
loop
    lda message,x
    jsr $ffd2
    inx
    cpx #$0d
bne loop
rts
message
   .text "hello, world!"

Once assembled (and loaded into memory), call with sys 828

** Yes, I know. Don't use the Kernal (probably also works in 128 native mode, I can't remember).

Shaun Bebbers

Posted 2015-08-28T12:23:59.027

Reputation: 1 059

Might be able to save a few bytes by counting the X index to zero if you reverse the string, like this [untested]: *=$033c ldx #$0c loop lda message,x jsr $ffd2 dex bne loop rts message .text "!dlrow ,olleh" – Shaun Bebbers – 2017-02-13T09:07:28.090

2Somehow I could 22 bytes in the basic solution, also 0?"HELLO, WORLD!" should work for 17 bytes. – NieDzejkob – 2017-04-29T17:25:31.927

1You know, you don't actually have to include the line numbers for the program to work. PRINT"HELLO, WORLD!" for 20 bytes will do fine. – MD XF – 2017-05-07T21:28:33.027

1Also, if Commodore 64 BASIC is like most old BASIC implementations (which I'm pretty sure it is) you could leave off the ending quote altogether. – MD XF – 2017-05-07T21:29:06.290

@NieDzejkob - using Commodore BASIC abbreviations does not save any bytes in the computer, it only saves typing. – Shaun Bebbers – 2017-05-08T14:43:00.280

@MDXF Unless you are doing a straight character count, rather than how much actual bytes you are using of the available free memory, then you are correct. However, without a line number, it is more difficult to say how much memory is being used as you're running in direct mode rather than keeping an executable symbolic listing in memory. – Shaun Bebbers – 2017-05-08T14:45:05.793

2

Hillberth, 32 bytes

[]H ,olH
.<   Wle
    ro
    ld!

If this code is weird looking, it's because the flow of an Hillberth program follows an Hilbert curve. So, the executed program is this:

[.<]H                                              !dlroW ,olleH

The code is similar to a Self-Modifying BrainFuck code, with the H command stopping the program.

TuxCopter

Posted 2015-08-28T12:23:59.027

Reputation: 3 661

2

Shakespeare, 2562 bytes

Here is the code, because Shakespearian does not play nice with stackexchange.

legoman5746

Posted 2015-08-28T12:23:59.027

Reputation: 21

I'm sorry, ignore that last comment. I clicked on the link to Shakespearian, not your code. Sorry about that, and welcome to the site! – DJMcMayhem – 2017-03-15T17:43:29.633

Surely this can be made shorter? As it stands, this is just a copy-paste of the language's stock Hello World program. – caseif – 2017-03-16T14:23:25.647

This prints Hello World!, not Hello, World!. – Dennis – 2017-06-29T06:15:46.120

2

KanyeC, 78 bytes

"A programming language based on the brilliance of Kanye West."

I am the greatest
make her say "Hello, World!"
I still think I am the greatest

Yes, it is essentially just an ArnoldC substitution, but I thought I'd contribute it for the sake of completeness.

caseif

Posted 2015-08-28T12:23:59.027

Reputation: 121

2

Traffic, 191 bytes

##########################
#+#+#+#+#*#+#+#+#*#*#+#+#+#
#7#9#9#9#3#4#3#8#3#3#9#9#3
#2#9#9#9#7#4#2#7#7#8#9#9#3
#0#2#9#9#3#0#0#0#3#3#9#1#0
#$#$#$#$#$#$#$#$#$#$#$#$#$#

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

Traffic is a 2D language modelled after cars moving around streets. Each car holds a value (acting as a variable).

This language is as bad at dealing with "strings" as Brainfuck is, so this is kinda bulky.

How it works

An ungolfed/more "proper" version of the above would look like this:

###########################
# # # # # # # # # # # # # #
#7#9#9#9#3#4#3#8#3#3#9#9#3#
#2#9#9#9#7#4#2#7#7#8#9#9#3#
#+#+#+#+#*#+#+#+#*#*#+#+#+#
# # # # # # # # # # # # # #
#0#2#9#9#3#0#0#0#3#3#9#1#0#
#$#$#$#$#$#$#$#$#$#$#$#$#$#

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

In this program, 13 cars are defined: all the digits directly adjacent to a $ (in the #$# constructions) become cars with that initial value. So the program begins with cars that have values 0 2 9 9 3 0 0 0 3 3 9 1 0. The cars' initial directions are away from the $.

The streets are defined as the space between #s; #s comprise the walls that cars can't pass through.

All the cars move upwards. They pass over the literal, ignoring it because they haven't seen an operator to use yet. Once the reach the top, they'll each see an operator (either + or *). On the next step, they'll all turn around because they hit a dead end.

Now when walking back downwards, they will observe the literal, since they have operators to use. After fully walking over each literal (i.e. reaching the start point again), each car performs its operation using the literal and assumes the result of the operation. This results in each car containing the ASCII value of a character in Hello, World!: 72 101 108 108 111 44 32 87 111 114 108 100 33.

Then they all step on the $. The $ is a street exit, and one of a few valid characters usable for those. The $ means to output the specified value and destroy the car. The output value for each $ is C, meaning to output the ASCII character given by the car's value.

After all cars hit their respective $s, there won't be any cars left in the field. Thus, the program terminates.

Business Cat

Posted 2015-08-28T12:23:59.027

Reputation: 8 357

2

NO!, 1178 bytes

NOOOOOOOOO?Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo Noooooooooooooooooooooooooooooooooooooooooooo Noooooooooooooooooooooooooooooooo Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo Nooooooooooooooooooooooooooooooooo
NOOOOOOOO?no

Because why not?

Don't ask. Just read the GitHub page.

Also please (and I beg you here) please say this out loud.

caird coinheringaahing

Posted 2015-08-28T12:23:59.027

Reputation: 6 705

2

HODOR, 2384 bytes

Walder
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
HODOR!
Hodor Hodor Hodor
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
HODOR!!!

I decided that my NO! answer wasn't long enough so I finished my commemoration of Hodor and spend a while coding this.

Hodor uses an accumulator because he's learning to count and can't remember more than 1 number.

In short (because I'm not doing a line-by-line explanation) these are the main commands:

Walder Hodor hodor hodor hodor Hodor hodor hodor hodor

Start the program because Hodor's original name was Walder

Hodor Hodor hodor hodor hodor hodor

Add 1 to the accumulator

Hodor! Hodor hodor hodor hodor hodor

Subtract 1 from the accumulator

HODOR! Hodor hodor hodor hodor hodor hodor hodor

Output the accumulator as a Unicode character

HODOR!!! Hodor Hodor (Hodor hodor hodor)

Kill Hodor (End the program)

caird coinheringaahing

Posted 2015-08-28T12:23:59.027

Reputation: 6 705

Dammit hodor, why? – lol – 2017-04-04T06:28:06.553

@SIGSEGV Hodor Hodor Hodor! Hodor? – caird coinheringaahing – 2017-04-04T06:34:01.497

You should answer this with HODOR: http://codegolf.stackexchange.com/questions/48907/hodorize-a-string

– Malivil – 2017-04-05T17:08:03.743

2

Turing, 18 bytes

put"Hello, World!"

Daniel Floca

Posted 2015-08-28T12:23:59.027

Reputation: 21

Is this the correct github page? https://github.com/Open-Turing-Project/OpenTuring

– mbomb007 – 2017-04-07T21:07:14.887

Welp, I'm blind. – Daniel Floca – 2017-04-07T21:11:49.323

2

Braingolf, 17 bytes

Got bored, made my own language, here's Hello World

"Hello, World!"&@

Explanation:

"Hello, World!"    Push the 13 chars of Hello World to the stack as charcode integers
               &@  Pop the entire stack and print as chars

Alternatively, here's hello world from before I added multi-char strings and printing:

#!#d#l#r#o#W# #,#o#l#l#e#H@@@@@@@@@@@@@

Explanation:

#!                                 Push the charcode of char '!' to the end of the stack
  ....................             Do this for every character in "Hello, World!" in reverse order
                      @@@@@@@@@@@@@  Pop and print the last element of the stack 13 times

Mayube

Posted 2015-08-28T12:23:59.027

Reputation: 4 938

>

  • outdated, 2. doesn't even print the right Hello, World!
  • < – ASCII-only – 2017-08-23T06:27:49.620

    @ASCII-only fixed – Mayube – 2017-08-23T08:20:22.433

    2

    MY, 1 byte.

    Here is the hex:

    FF
    

    I'm finally ready to reveal my language. It's still a major WIP, and the undefined byte meaning is temporary (except for maybe 0xFF). I will eventually update this to include a non-hacky solution when MY is able to do that.

    Zacharý

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 340

    I did add another solution, this time not relying on a built-in! https://codegolf.stackexchange.com/questions/55422/hello-world/127294#127294

    – Zacharý – 2017-06-19T20:51:27.810

    2

    SASS, 32 bytes?

    \:after
      content:"Hello, World!"
    

    arodebaugh

    Posted 2015-08-28T12:23:59.027

    Reputation: 212

    2

    Klein, 16 + 3 = 19 bytes

    "Hello, World!"@
    
    • +3 for -A flag
    • Also contains a null argument for the topology, I'm not even sure how to score that.

    Try it online!

    Competing for the bounty.

    ATaco

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 373

    4

    Not competing for the bounty, Wheat Wizard stated in chat that he wouldn't award it to those using " (otherwise this would be a trivial bounty).

    – Okx – 2017-05-19T06:18:52.793

    2

    StupidScript, 214 bytes

    It's a joke language that I just made. Mark Watney would be proud.

    80.5 0.0
    80.5 23.0
    69.0 103.5
    69.0 161.0
    80.5 46.0
    23.0 0.0
    23.0 23.0
    46.0 92.0
    69.0 57.5
    69.0 138.0
    69.0 138.0
    69.0 172.5
    23.0 138.0
    23.0 0.0
    57.5 80.5
    69.0 172.5
    80.5 23.0
    69.0 138.0
    69.0 46.0
    23.0 11.5
    23.0 23.0
    

    AH L

    Posted 2015-08-28T12:23:59.027

    Reputation: 377

    +1 for the language name and obfuscated-ness. – MD XF – 2017-05-30T19:55:07.833

    2

    ;#

    Interpreter provided by @ETHProductions

    Read this for a full list of commands.

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

    caird coinheringaahing

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 705

    Sorry, not a language :( – Esolanging Fruit – 2017-06-04T06:47:32.223

    @Challenger5 kolmogorov-complexity challenge. Doesn't have to be – caird coinheringaahing – 2017-06-04T11:51:53.907

    Oh yeah, that's true. Never mind. – Esolanging Fruit – 2017-06-04T15:50:57.237

    2

    Fishing, 25 24 bytes

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

    It exits with an error.

    Fishing, 34 bytes

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

    Without errors.

    jimmy23013

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 688

    2

    Lean Mean Bean Machine, 55 bytes

    OOOOOOOOOOOOO
    """""""""""""
    Hello, World!
    !!!!!!!!!!!!!
    

    I think this is the shortest.

    Here's a somewhat more entertaining alternative approach in 96 bytes:

    OOOOOOOOOO
    """
    Hel
    !!!""""
      !o, W
       !!!!
    
    
    
       !   "
           r
           !""
      !     d!
            !!
    

    This one only sets 1 marble to each letter, and re-uses the l and o marbles, much less golfy, but more true to the spirit of the language.

    Mayube

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 938

    2

    Emoji, 23 24 bytes

    Hello, World!➡ 
    

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

    ABot

    Posted 2015-08-28T12:23:59.027

    Reputation: 163

    2

    Shtriped, 239 bytes

    e n
    e b
    i b
    + x y
     +
      i x
      d y
      +
     +
     d x
    0
     + b b b
    1
     + b n n
     0
    z x
     d x
     z x
    D
     1
     s n
     z n n
     z b b
     i b
    Y
     0
     0
    Z
     1
     Y
     Y
    B
     0
     1
    1
    Z
    1
    Y
    1
    Y
    D
    B
    B
    1
    0
    Z
    Y
    D
    B
    1
    Y
    B
    0
    Z
    D
    1
    B
    B
    Y
    1
    0
    D
    Y
    1
    1
    Y
    B
    Z
    D
    B
    Y
    1
    0
    Z
    Y
    D
    B
    1
    1
    1
    1
    B
    0
    D
    

    Try it online!

    This Hello, World! in Shtriped terminates somewhat quickly, since it doesn't encode the entire string in one number.

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 859

    2

    Set, 123 bytes

    set ! H
    set ! 101
    set ! 108
    set ! 108
    set ! 111
    set ! 44
    set ! 32
    set ! 87
    set ! 111
    set ! 114
    set ! 108
    set ! 100
    set ! 33
    

    Needed to use raw ASCII codes because lowercase letters are reserved for variable names.

    Try it online!

    MD XF

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 337

    Wow, someone actually used this language. I'm both surprised and very happy – Matheus Avellar – 2017-08-10T01:58:45.357

    1

    @MatheusAvellar If you haven't yet noticed it has been used in the largest polyglot in existence.

    – MD XF – 2017-08-10T03:55:36.847

    I had no idea! That's the coolest! Hahaha – Matheus Avellar – 2017-08-10T09:05:35.330

    2

    MY, 60 bytes

    27á'←1Aá'←8Aá'2×←1Bá'←44á'←2Ġ'←78á'←1Bá'←4Bá'←8Aá'←AȦ'←33á'←
    

    MY IS ON TIO!!

    How?

    Outputs H, e, ll, o, <space>, W, o, r, l, d, ! to the console.

    I created a 3rd answer to this question due to the differing techniques used, this uses concatenation on numbers (27á pushes 72), one uses increment and decrement, while another uses a builtin.

    Zacharý

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 340

    2

    DOBELA, 214 bytes

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

    With comments:

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

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

    Try it online

    stasoid

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 177

    2

    LNUSP, 360 bytes

    001 . !.!
    002 !    !
    001 .  !!
    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 the newline at the end. Some explanations are here. Can be golfed 4 bytes more, I didn't do it for aesthetic purpose.

    Try it online

    stasoid

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 177

    2

    Triangularity, 71 49 bytes

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

    Try it online!

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

    Old version

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

    Try it online!

    caird coinheringaahing

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 705

    2

    Min, 20 bytes

    "Hello, World!" puts
    

    Panda0nEarth

    Posted 2015-08-28T12:23:59.027

    Reputation: 71

    2

    ALPHA, 36 bytes

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

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

    KMDHello World!DMK
    

    Explanation:

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

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

    SnivyDroid

    Posted 2015-08-28T12:23:59.027

    Reputation: 51

    2

    Brainfuck, 128

    Generated using this generator, which is sub-optimal.

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

    mbomb007

    Posted 2015-08-28T12:23:59.027

    Reputation: 16 876

    Now we have a 95-byte BF. – Alex A. – 2015-08-28T17:32:34.477

    1Make that 92. – LegionMammal978 – 2015-09-01T21:48:58.717

    @LegionMammal978 Yeah, thanks. I've already seen it. – mbomb007 – 2015-09-01T21:50:56.373

    @mbomb007 Okay, it's just that it annoys me when I see multiple entries in the same language. – LegionMammal978 – 2015-09-01T21:56:07.310

    @LegionMammal978 Then use the leaderboard snippet. – mbomb007 – 2015-09-01T21:56:31.390

    2

    FlogScript, 17 bytes

    {Hello, World!}P.
    

    mbomb007

    Posted 2015-08-28T12:23:59.027

    Reputation: 16 876

    2

    Perl, 18 bytes

    say"Hello, World!"
    

    Remark:

    "say" is used in Perl 6. While "print" is a Perl 5 thing. But "say" can be used in version 5.10+ when the -M5.010 switch (or -M for a higher version) is used.

    Perl 5 without version switch, 20 bytes

    print"Hello, World!"
    

    Perl/Tk, 91 Bytes

    Ok, this doesn't exactly print to STDOUT as was requested by the challenge. Since it creates a window with a button. So this was just added for the sake of entertainment/completeness.

    use Tk;MainWindow->new->Button(-text=>"Hello, World!",-command=>sub{exit})->pack();MainLoop
    

    Perl/Tk Hello, World!

    LukStorms

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 686

    1

    You can shave off 2 bytes by replacing print with say, provided the OP agrees with this meta post in -M5.010 being free.

    – Slade – 2015-08-28T15:54:53.760

    I knew "say" is used in Perl 6, but didn't realise they added it to a more recent version of Perl 5 than the one I use. So I added both to the post. – LukStorms – 2015-08-28T19:42:32.967

    There is another Perl 6 answer, so maybe you could just post the Perl 5 one.

    – LegionMammal978 – 2015-09-01T21:41:54.100

    2

    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.

    Buzz

    Posted 2015-08-28T12:23:59.027

    Reputation: 121

    i changed the code a little so it doesn't show the quotes – Buzz – 2015-08-31T14:20:56.737

    Are the quote marks necessary in case of display? The H in Hello needs to be upper-case btw. – CoDEmanX – 2015-09-03T00:16:16.850

    @CoDEmanX Yeah the quotes are necessary. Otherwise it thinks its a variable. – Buzz – 2015-09-03T13:30:53.323

    Sure you can't get rid of the space before "? – Lynn – 2015-09-04T14:08:48.843

    That space can be removed. Normally scheme needs the spaces to tell two things apart. but in this case it doesn't need it – Buzz – 2015-09-04T14:28:27.647

    2

    Intel syntax x86 Assembly, ?? bytes

    mov %dx, msg
    msg db 'Hello, World!'
    mov %ah, 9
    int 21h
    

    I can't compile it as of now but I will do it and get the byte count.

    georgeunix

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 573

    3First of all, this doesn't look complete; assuming this is for MS-DOS, you need to also populate ah and call int 21. Second, AT&T syntax reverses the operands; it needs to be mov msg, %dx. – Random832 – 2015-08-28T17:44:37.013

    Strange! GAS accepted it. – georgeunix – 2015-08-28T17:48:55.823

    @Random832 I've fixed it for DOS. It's strange that GAS (default AT&T) accepted the code before? – georgeunix – 2015-08-28T17:54:23.043

    2Is it really using AT&T syntax? I'd have expected .ascii instead of db, and 0x21 instead of 21h. – Random832 – 2015-08-28T17:56:02.067

    no, the int 21h ah=9 is the print call. What environment are you testing this on? – Random832 – 2015-08-28T17:57:37.397

    @Random832 I apologise. I wasn't reading properly – georgeunix – 2015-08-28T17:58:49.513

    I've changed it to Intel syntax. I've never used AT&T syntax before, let alone DOS ASM. – georgeunix – 2015-08-29T04:35:39.600

    This program doesn't seem to exit. Won't it execute arbitrary machine code? – ugoren – 2015-08-30T13:25:52.737

    The program doesn't call the terminate interrupt. So no, it won't exit. – georgeunix – 2015-08-31T12:04:49.353

    2

    Common LISP, 22 bytes

    (princ"Hello, World!")
    

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    2

    RPython, 60 bytes

    def e():print'Hello, World!';return 0
    target=lambda*_:e,None
    

    refi64

    Posted 2015-08-28T12:23:59.027

    Reputation: 7 567

    2

    Idris, 36 bytes

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

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

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    2

    CoffeeScript, 21 bytes

    alert "Hello, World!"
    

    or console.log "Hello, World!", if that's closer to STDOUT for your tastes.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    2

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

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    2

    Mathematica, 21 bytes

    Print@"Hello, World!"
    

    Mathemaica 10.3, 20 bytes

    Echo@"Hello, World!"
    

    alephalpha

    Posted 2015-08-28T12:23:59.027

    Reputation: 18 628

    3Feel free to count the 10.3 version as the main solution and include the older one for reference. – Martin Ender – 2015-11-10T13:38:38.113

    2

    Fueue, 47 bytes

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

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    2

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

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    2

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

    Peter Taylor

    Posted 2015-08-28T12:23:59.027

    Reputation: 37 961

    2

    99, 283 bytes

    999 9 9
    99 99999999 999 9
    99
    99 99999 9 999 9
    99
    99 99 999 999999
    99
    99
    99 9999999 9999 999 9
    99
    99 99 9999999 9 999 9 999 9 999 9
    99
    99 99 999999 9 999999 9
    99
    9999
    99 99999 999 999999 999 9
    99
    99 9999999 9999 9 999 9
    99
    99 99 999999 9
    99
    99 99 999999 999 9
    99
    99 99999 9999999 9
    99
    

    This was handcrafted so it is very likely suboptimal. Someone should write a metagolfer...

    The following table has been quite useful writing 99 code by hand:

    Variable  /9%128    Can print?
    
    9              1 
    99            11    !
    999          111 
    9999          87    !
    99999        103 
    999999         7    !
    9999999       71 
    99999999      71    !
    

    All further rep-digits of 9 also yield 71 when taken modulo 128 (after dividing by 9).

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 162 549

    All further rep-digits of 9 also yield 71 when taken modulo 128. you can't just drop these math facts like they're nothing.now i'm going to be amazed all day – undergroundmonorail – 2015-08-30T14:04:26.547

    @undergroundmonorail Note that it's actually the rep-digits of 1 which do this, because the variable is divided by 9 before taking the modulo. And the reason this works is that (710 % 128) happens to be 70. – Martin Ender – 2015-08-30T14:09:39.427

    2

    Maxima, 23 bytes

    print("Hello, World!")$
    

    alephalpha

    Posted 2015-08-28T12:23:59.027

    Reputation: 18 628

    2

    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
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    2

    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:

    Hello, World! HPPPL

    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

    M L

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 445

    1Is the space between the right parenthesis and begin needed? – refi64 – 2015-09-01T13:55:49.040

    @kirbyfan64sos Thanks for the hint. No, it’s not necessary. – M L – 2015-09-01T14:30:37.013

    2

    az, 16 bytes

    "Hello, World!".
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    2

    TRANSCRIPT, 36 bytes

    He is here.
    >HE, Hello, World!
    >X HE
    

    The second line sets HE, and the third line outputs it.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    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 – 2015-09-01T13:02:40.823

    @Sp3000 You're right, I just looked at the interpreter and found that it only matches two-letter words or longer. – LegionMammal978 – 2015-09-01T21:15:39.153

    1@LegionMammal978 You should use He. – mbomb007 – 2015-09-01T21:55:13.967

    2

    Cardinal, 15 bytes

    %"Hello, World!
    

    M L

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 445

    2

    LMNtal, 35 bytes

    io.use.io.print("Hello, World!",_).
    

    A weird programming language from Japan that seems to be inspired by Prolog.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    2

    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?

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    2

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 162 549

    2

    Jasmin, 251 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 java/lang/Object
    .method public static main([Ljava/lang/String;)V
    .limit stack 2
    getstatic java/lang/System/out Ljava/io/PrintStream;
    ldc "Hello, World!"
    invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V
    return
    .end method
    

    This program is based off the "Hello, World!" program by SJSU. Golfing mainly entailed removing comments and unnecessary white space. 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.

    ankh-morpork

    Posted 2015-08-28T12:23:59.027

    Reputation: 840

    2

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

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 162 549

    2

    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

    MickyT

    Posted 2015-08-28T12:23:59.027

    Reputation: 9 062

    2

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 162 549

    2

    Wake, 16 bytes

    :"Hello, World!"
    

    Not much room for golfing.

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    2

    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!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    2

    ShortScript, 2 bytes

    By using the function from the standard library:

    $H
    

    And by not using it:

    →Hello, World!
    

    YourDeathIsComing

    Posted 2015-08-28T12:23:59.027

    Reputation: 71

    That library seems to be missing from your reference implementation on Esolang. – Dennis – 2015-09-04T14:17:33.803

    Yes, I the current version is a bit buggy – YourDeathIsComing – 2015-09-04T16:58:27.453

    I have updated the esolangs page. Now it will work. – YourDeathIsComing – 2015-09-04T17:48:25.107

    That implementation doesn't seem to print the exclamation point. – Dennis – 2015-09-04T17:58:40.533

    I will fix it tomorrow, when I am at PC. – YourDeathIsComing – 2015-09-05T21:02:47.900

    I have fixed it. – YourDeathIsComing – 2015-09-06T09:41:33.347

    2

    Quipu, 41 bytes

    'H
    'e
    'l
    'l
    'o
    ',
    ' 
    'W
    'o
    'r
    'l
    'd
    '!
    /\
    

    Quipu looks like an interesting language, but I don't think there's anything to golf off this "Hello, World!" example from the esolangs page.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 162 549

    2

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

    The_Basset_Hound

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 121

    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 +.? – Martin Ender – 2015-09-05T21:24:49.040

    @MartinBüttner Yes, oops. – The_Basset_Hound – 2015-09-05T21:26:09.540

    @MartinBüttner Actually, the byte count is the same. – The_Basset_Hound – 2015-09-05T21:29:19.587

    +|72|.+|101|.&gt;+|108|..&gt;+|111|.&gt;+|44|.-|32|.+|87|.&lt;.+++.&lt;.&lt;-.-|33|. for 66 – Sp3000 – 2015-09-06T05:33:12.720

    @Sp3000 Welp, already getting my butt kicked at my own language. – The_Basset_Hound – 2015-09-06T20:07:13.873

    2

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

    Paŭlo Ebermann

    Posted 2015-08-28T12:23:59.027

    Reputation: 870

    2

    Symball, 47 bytes

    '0H'0e'0l'0l'0o*59$-$1$'1$'0_'0W'0o'0r'0l'0d'1-
    

    Try it here. (dead link)

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    The link is dead. – LegionMammal978 – 2015-09-30T00:20:01.783

    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... – Dennis – 2015-09-30T00:25:04.137

    2

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 162 549

    2

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

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    2

    C#, 67 Bytes

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

    Ken Gregory

    Posted 2015-08-28T12:23:59.027

    Reputation: 151

    This has been posted before

    – RobIII – 2015-10-02T13:03:07.977

    I missed it. Sorry. – Ken Gregory – 2015-10-02T18:07:52.887

    2

    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.

    El'endia Starman

    Posted 2015-08-28T12:23:59.027

    Reputation: 10 944

    From the explanation, it sounds like the parentheses can be dropped. But correct me if I'm wrong. – SuperJedi224 – 2015-10-16T11:17:20.643

    @SuperJedi224: The parentheses are the while loop. The O outputs the top of stack as a character. – El'endia Starman – 2015-10-16T17:08:43.230

    But I think you can just do that once without the loop. – SuperJedi224 – 2015-10-16T19:29:19.490

    @SuperJedi224: It would only output "H". – El'endia Starman – 2015-10-16T20:13:25.143

    Oh, so it pushes the individual characters and not the entire string at once. Thanks for explaining that for me. – SuperJedi224 – 2015-10-16T20:33:21.247

    @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. – El'endia Starman – 2015-10-18T00:47:26.667

    2

    BotEngine, 2x15=30

    vHello, World!
    >eeeeeeeeeeeeeP
    

    SuperJedi224

    Posted 2015-08-28T12:23:59.027

    Reputation: 9 433

    2

    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;
    }
    <!--
    Designed and written 2015 by D. Loscutoff
    Much of the HTML and CSS was taken from this Befunge interpreter by Ingo Bürk: http://codegolf.stackexchange.com/a/40331/16766
    -->
    <div class="container">
      <textarea id="source" placeholder="Enter your program here" wrap="off">S"Hello, World!"1(
    13wSoL!(</textarea>
      <div id="source-display-wrapper">
        <div id="source-display"></div>
      </div>
    </div>
    <div id="stdin-container" class="container">
      <textarea id="stdin" placeholder="Input" wrap="off"></textarea>
    </div>
    <div id="controls-container" class="container clearfix">
      <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()" />
    </div>
    <div id="stdout-container" class="container">
      <textarea id="stdout" placeholder="Output" wrap="off" readonly></textarea>
    </div>
    <div id="options-container" class="container">
      <div class="option so-box">Steps per Second: <span id="steps-per-second" contenteditable>100</span>
      </div>
    </div>

    DLosc

    Posted 2015-08-28T12:23:59.027

    Reputation: 17 064

    2

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

    Adnan

    Posted 2015-08-28T12:23:59.027

    Reputation: 33 457

    2

    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.

    Mego

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 191

    2

    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.

    bkul

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 452

    2No need for the disclaimer here. Newer languages are allowed and even encouraged this time. – Martin Ender – 2015-11-22T15:11:08.880

    2

    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.

    TheNumberOne

    Posted 2015-08-28T12:23:59.027

    Reputation: 9 230

    2

    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.

    errorseven

    Posted 2015-08-28T12:23:59.027

    Reputation: 220

    1Greetings from the future! I can't tell if this worked at the time but it works now and its 27 bytes: FileAppend,Hello`, World!,* – Engineer Toast – 2017-04-05T15:53:25.707

    2

    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.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    2

    Par, 14 bytes

    `Hello, World!
    

    I don't know Par, but it looks golfy.

    lirtosiast

    Posted 2015-08-28T12:23:59.027

    Reputation: 15 125

    2

    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.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    2

    Factor, 17 21 bytes

    Push a string, then print it without quotes.

    "Hello, World!" print
    

    cat

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 037

    2

    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.

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 859

    This is a catalogue, is it not? Therefore, this answer is completely valid. – SuperJedi224 – 2015-12-15T23:13:04.063

    @SuperJedi224 Indeed, yes. Fixing. – Conor O'Brien – 2015-12-15T23:14:34.303

    2

    Samau, 15 bytes

    "Hello, World!"
    

    Samau is yet another stack-based golfing language.

    alephalpha

    Posted 2015-08-28T12:23:59.027

    Reputation: 18 628

    2

    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.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1Hi, 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. – Ørjan Johansen – 2017-04-18T01:41:58.267

    2

    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.

    DarkPhantom

    Posted 2015-08-28T12:23:59.027

    Reputation: 191

    2

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

    yeti

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 278

    2

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

    yeti

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 278

    2

    Visual Basic.NET, 63 bytes

    Module A
    Sub Main
    System.Console.Write("Hello, World!")
    End Sub
    End Module
    

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    2

    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.

    user48538

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 209

    1

    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 – 2016-01-02T12:39:19.303

    @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. – user48538 – 2016-01-02T12:43:12.417

    @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 – 2016-01-02T14:49:26.253

    @SuperJedi224 That was an example. :-P – wizzwizz4 – 2016-01-02T15:19:26.627

    @zyabin101 You don't need much reputation to chat. – wizzwizz4 – 2016-01-02T15:19:51.787

    @SuperJedi224 Or you could type 42..s() – Stefnotch – 2016-01-14T14:40:22.910

    2

    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!

    Jerry Jeremiah

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 107

    2

    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.

    Cyoce

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 273

    2

    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:

    ~#~~#~~~@*~##~~#~#@*~##~##~~@:**~##~####@*~~#~##~~@*~~#~~~~~@*~#~#~###@*~##~####@*~###~~#~@*~##~##~~@*~##~~#~~@*~~#~~~~#@*
    

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 859

    2

    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.

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 859

    2

    Oration, 28 bytes

    listen
    capture Hello, World!
    

    Fun to write.

    Riker

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 743

    You can include the 32-byte version: Literally, print("Hello, World!"). – Conor O'Brien – 2016-02-26T19:37:41.097

    Ooh nice, thanks @CᴏɴᴏʀO'Bʀɪᴇɴ . – Riker – 2016-02-26T21:37:19.417

    Can I figuratively print something? :P – Downgoat – 2016-04-12T04:22:13.487

    @Downgoat yes, but the compiler ignores such frivolity. – Riker – 2016-04-12T15:27:11.033

    Can't you remove \nthat's it? – Erik the Outgolfer – 2016-06-17T10:48:21.980

    @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ yeah, forgot I fixed/messed that up when I added python 2 support. – Riker – 2016-06-17T13:12:00.173

    @EᴀsᴛᴇʀʟʏIʀᴋ Now you can replace your older version with the newer one. – Erik the Outgolfer – 2016-06-17T13:47:25.567

    @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ ---yeah, I did.--- er thanks – Riker – 2016-06-17T13:47:40.907

    2

    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  ~##~~#~~@*
    !  ~~#~~~~#@*
    

    ETHproductions

    Posted 2015-08-28T12:23:59.027

    Reputation: 42 391

    Fantastic job!! – Conor O'Brien – 2016-03-02T19:37:36.787

    ::**==:*:*. – CalculatorFeline – 2016-03-25T23:48:50.007

    @CalculatorFeline Yeah, it can be either way. – ETHproductions – 2016-09-07T02:25:02.043

    2

    Javascript (Nashorn), 22 bytes

    Nashorn is the JS engine that comes built in to Java.

    print('Hello, World!')
    

    SuperJedi224

    Posted 2015-08-28T12:23:59.027

    Reputation: 9 433

    2

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

    Zach Gates

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 428

    2

    Verilog, 60 bytes

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

    Try it online here.

    Justin

    Posted 2015-08-28T12:23:59.027

    Reputation: 17 266

    2

    Scratch, 2 blocks

    enter image description here

    Self explanatory really.

    user51533

    Posted 2015-08-28T12:23:59.027

    Reputation:

    2

    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 – 2016-03-24T21:13:52.960

    1@quartata That means this script takes up 43 bytes. – haykam – 2016-07-20T04:06:38.237

    2

    JavaScript (Node.js), 28 bytes

    console.log("Hello, World!")
    

    Michał Perłakowski

    Posted 2015-08-28T12:23:59.027

    Reputation: 510

    We already have a JavaScript answer at 22 bytes.

    – Zach Gates – 2016-04-02T20:07:48.833

    1@ZachGates But that answer runs in browser environment. My answer runs in Node.js. – Michał Perłakowski – 2016-04-02T20:08:27.403

    2

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

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 859

    2

    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.

    CensoredUsername

    Posted 2015-08-28T12:23:59.027

    Reputation: 716

    2

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

    Leaky Nun

    Posted 2015-08-28T12:23:59.027

    Reputation: 37 559

    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. – Martin Ender – 2016-04-26T11:39:27.863

    2

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

    m654

    Posted 2015-08-28T12:23:59.027

    Reputation: 636

    OP says you can use languages made after this challenge. – Erik the Outgolfer – 2016-06-02T19:37:43.070

    @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Yeah, I know, but using a builtin Hello World seems kind of like cheating. – m654 – 2016-06-03T11:11:45.847

    2If 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! – Erik the Outgolfer – 2016-06-03T11:14:05.640

    2Unlike 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. – Erik the Outgolfer – 2016-06-03T11:15:22.723

    @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Oh, I didn't notice that :P – m654 – 2016-06-03T11:15:25.540

    Which of them?? – Erik the Outgolfer – 2016-06-03T11:15:46.100

    @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ First one. – m654 – 2016-06-03T11:16:12.227

    2

    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.

    dorukayhan

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 166

    @downvoter Did you get a smaller/larger executable? – dorukayhan – 2017-01-10T22:30:16.453

    2

    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.

    TuxCopter

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 661

    remove the AND's for more golfing – Rohan Jhunjhunwala – 2016-09-25T01:22:01.917

    2

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

    weatherman115

    Posted 2015-08-28T12:23:59.027

    Reputation: 525

    2Can't you do return"Hello, World!"? – Erik the Outgolfer – 2016-06-29T21:41:53.397

    2

    DOG, 20 bytes

    bark "Hello, World!"
    

    Business Cat

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 357

    2

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

    Maliafo

    Posted 2015-08-28T12:23:59.027

    Reputation: 361

    2

    S.I.L.O.S, 19 bytes

    print Hello, World!
    

    Seems legit!

    Rohan Jhunjhunwala

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 878

    2This is a 19 bytes. – Conor O'Brien – 2016-09-16T00:00:07.147

    @ConorO'Brien whops, I can progam, but I can't count to 19.... :( – Rohan Jhunjhunwala – 2016-09-16T01:13:56.523

    4Ironic... the nineteenth byte ;) – Conor O'Brien – 2016-09-16T01:22:49.487

    2

    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
    

    TuxCopter

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 661

    like the theme lol – Rohan Jhunjhunwala – 2016-09-16T01:16:38.830

    2

    Jellyfish, 15 bytes

    P"Hello, World!
    

    Try it online!

    Not terribly interesting, but for completeness' sake...

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 162 549

    2

    x86/x86_64 on Linux, 34 32 31 bytes

    e8 0d 00 00 00          call   <+0x12>
    
    48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21
                            "Hello, World!"
    
    59                      pop    %ecx
    6a 01                   push   $0x1
    5b                      pop    %ebx
    6a 0d                   push   $0xd
    5a                      pop    %edx
    6a 04                   push   $0x4
    58                      pop    %eax
    cd 80                   int    $0x80
    c3                      ret
    

    Main differences between this one and grc's version: mine makes no assumption of prior register contents, works in both x86 and x86_64 modes and does a ret in lieu of a sys_exit() syscall.

    If you want to Try it online!, compile and run the following C program.

    const char main[]="\xe8\r\0\0\0Hello, World!Yj\1[j\rZj\4X\xcd\x80\xc3";
    

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

    ceilingcat

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 384

    2

    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

    TuxCopter

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 661

    -1 language name makes me want cake :P – Downgoat – 2016-08-15T19:54:41.600

    2

    Processing, 23 bytes

    print("Hello, world!");
    

    It also opens a window for drawing, but this message does go to stdout in the IDE.

    I don't understand why more people don't use Processing over Java for code golf. With most of the boilerplate removed, you can almost always outdo it with the same syntax.

    Cody

    Posted 2015-08-28T12:23:59.027

    Reputation: 437

    2

    Ru, 15 bytes

    “Hello, World!”
    

    Body must be at least 30 characters; you entered 29.

    TuxCopter

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 661

    2

    haXe, 56 bytes

    class H{static function main(){trace("Hello, World!");}}
    

    Test it online!

    ETHproductions

    Posted 2015-08-28T12:23:59.027

    Reputation: 42 391

    2

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

    Qwerp-Derp

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 815

    1This prints Hmllo,World on TIO. – Dennis – 2016-12-03T00:51:17.397

    1

    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.

    Kelly Lowder

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 358

    3the one thing mathematica doesn't have a builtin for! – FlipTack – 2016-11-19T10:23:33.393

    1

    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
    

    Esolanging Fruit

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 495

    Yeah... unless you have an interpreter from before the challenge that works with 43 bytes, it doesn't count as 43. – Destructible Lemon – 2016-11-27T22:56:53.300

    @DestructibleWatermelon Ok, I edited that out. – Esolanging Fruit – 2016-11-28T00:46:35.333

    1

    Kitanai, 20 bytes

    print"Hello, World!"
    

    Pretty easy to understand :)

    Sygmei

    Posted 2015-08-28T12:23:59.027

    Reputation: 676

    1

    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.

    1. Somme is stack-based.
    2. The numbers 0-9 push that number, along with A-F pushing 10-15.
    3. The above are treated as 0-arity functions.
    4. 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.
    5. m, prints the stack as characters.

    I'll add some more explanation later.

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 859

    1

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

    G B

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 140

    Seg fault on my system. – MD XF – 2017-03-06T22:56:32.483

    Works on Ubuntiu 16.04.04 using gcc 5.4.0 – G B – 2017-03-07T07:13:26.197

    1

    8th, 16 17 bytes

    "Hello, World!" .
    

    Push the string on TOS. Then print the item on stack with .

    Chaos Manor

    Posted 2015-08-28T12:23:59.027

    Reputation: 461

    With version 17.01 of 8th a bug has been fixed. Therefore a space before . is strictly required. – Chaos Manor – 2017-02-06T19:35:51.203

    1

    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.

    steenbergh

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 474

    1

    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
    

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 859

    1

    C++, 54 bytes

    #include<iostream>
    main(){std::cout<<"Hello, World!";}
    

    Try Me Online!

    GCaldL

    Posted 2015-08-28T12:23:59.027

    Reputation: 21

    #include&lt;cstdlib&gt; main(){puts("Hello, World!");} is shorter and still C++ (newline after include, not space) – NieDzejkob – 2017-04-29T17:37:56.407

    You can save a byte by removing the space between #include and &lt;iostream&gt;. i.e. #include&lt;iostream&gt; instead of #include &lt;iostream&gt; – Elronnd – 2017-05-01T00:57:23.537

    There are so many better ways to do this. – MD XF – 2017-05-13T04:11:02.843

    1

    SQLite, 22 bytes

    select"Hello, World!";
    

    Try it online!

    Pavel

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 211

    1

    Ada, 83 characters

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

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

    I'm not sure if this can be made shorter...

    Copy the code into http://tutorialspoint.com/compile_ada_online.php to try it.

    python-b5

    Posted 2015-08-28T12:23:59.027

    Reputation: 79

    1

    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.

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    JSFuck, 22948 bytes

    [][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([][[]]+[])[!+[]+!+[]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+[+!+[]])+[])+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()
    

    rabbitforpm

    Posted 2015-08-28T12:23:59.027

    Reputation: 11

    1Welcome 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. – ETHproductions – 2017-02-25T20:44:42.350

    1

    D, 55 53 52 bytes

    import std.stdio;void main(){"Hello, World!".write;}
    

    Elronnd

    Posted 2015-08-28T12:23:59.027

    Reputation: 91

    1You can save 2 bytes, by removing \n – Khaled.K – 2017-04-30T23:08:44.910

    1Capitalization is important. (i.e. change world to World). And won't "Hello, World!".write work? – Zacharý – 2017-05-09T00:46:18.387

    1

    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.

    ETHproductions

    Posted 2015-08-28T12:23:59.027

    Reputation: 42 391

    1

    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

    fəˈnɛtɪk

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 068

    1

    √ å ı ¥ ® Ï Ø ¿ , 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...

    caird coinheringaahing

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 705

    1

    Charcoal, 13 bytes

    Hello, World!
    

    Charcoal prints the canvas state at the end of execution, and any run of ASCII characters is considered a string, which is implicitly printed to the canvas.

    ASCII-only

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 518

    1

    ASP / VBSCRIPT, 13 bytes

    Another boring answer!

    Hello, World!
    

    Shaggy

    Posted 2015-08-28T12:23:59.027

    Reputation: 12 430

    1

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

    caird coinheringaahing

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 705

    @ovs "This uses UTF-32 encoding" – Nic Hartley – 2017-05-02T18:17:20.923

    This is not a programming language. – Esolanging Fruit – 2017-05-25T04:29:06.767

    1

    shortC, 26 21 19 16 bytes

    AR"Hello, World!
    

    Just to showcase the language.

    MD XF

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 337

    1

    2Col, 2 bytes

    HW
    

    Hooray, another boring answer using a Hello world builtin.

    Mayube

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 938

    Does this print Hello, World! exactly or some variant of it? – Beta Decay – 2017-05-24T11:56:15.973

    @BetaDecay prints it exactly, followed by a trailing newline – Mayube – 2017-05-24T12:15:15.107

    Oh nice. A few answers have had built ins which don't print it correctly – Beta Decay – 2017-05-24T12:16:10.930

    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 – Mayube – 2017-05-24T12:17:11.077

    1

    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!
    

    isaacg

    Posted 2015-08-28T12:23:59.027

    Reputation: 33 634

    Probably the best and most ultimate ever golfing language using only printable ASCII and newlines, now packed! – Erik the Outgolfer – 2017-05-25T15:24:43.490

    1

    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
    

    Beta Decay

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 590

    1

    Neim, 16 bytes

    (Hello, World!)B
    

    Try here

    Made possible thanks to (partial) BigInteger support.

    Erik the Outgolfer

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 165

    1

    Plain English 900 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 error stream." into the i/o error; exit.
    

    The Plain English IDE is available at github.com/Folds/english. The IDE runs on Windows. It compiles to 32-bit x86 code.

    Write a buffer to stdout and Get stdout returning a standard handle seem like good candidates for adding to Plain English's library. Similar routines already exist for stderr.

    Jasper

    Posted 2015-08-28T12:23:59.027

    Reputation: 379

    Seems like a very interesting language, but very verbose. Wow! – Neil A. – 2017-06-28T06:35:40.260

    Is there a character I am missing? It shows up as 307/899 bytes for me, respectively – Neil A. – 2017-06-28T06:37:00.590

    @NeilA. - Your counts are probably correct. I estimated the byte counts by adding up the (1-based) indexes of the character positions after the last character on each line. It is likely that this process resulted in an extra character being counted after the last line. This process also assumes that the lines can be separated using one byte (such as a space or line feed) instead of the actual two-byte CRLF that is used when the editor saves the file. But since Plain English is designed to successfully compile the file if the CRLFs were replaced by spaces, the latter issue is not a problem. – Jasper – 2017-06-28T15:45:18.097

    @NeilA. -- My first stab at the problem was much shorter (about 76 bytes), but it launched a complete CGI environment and output to that environment's stdout. This version outputs in the stdout that the user starts in. If I make Plain English treat stdout as nicely as it treats stderr, this version can be shortened to about 88 bytes. – Jasper – 2017-06-28T15:55:25.667

    @programmer5000 -- According to the rules of this challenge, "The program must not write anything to STDERR." – Jasper – 2017-07-19T15:28:54.230

    1

    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
    

    Stephen

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 598

    1

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

    Gemdude46

    Posted 2015-08-28T12:23:59.027

    Reputation: 11

    1

    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
    

    Jerry Jeremiah

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 107

    1

    Aheui, 147 144 bytes

    발따밤따빠받나파빠밣다빠밦다빠받타밢밢따밦다밤밣따밦밦따빠밣다파받따빠받다파빠빠밠타밣밢따아멓희
    

    Sait2000

    Posted 2015-08-28T12:23:59.027

    Reputation: 31

    1

    Ly, 19 18 bytes

    "!dlroW ,olleH"[o]
    

    First submission in my new language!

    LyricLy

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 134

    1

    Positron, 21 bytes

    print@"Hello, World!"
    

    Try it online!

    Just to get this out there :)

    HyperNeutrino

    Posted 2015-08-28T12:23:59.027

    Reputation: 17 180

    1

    Emmental, 68 bytes

    #0#10#33#100#108#114#111#119#32#44#111#108#108#101#72...............
    

    From the esolangs.org page.

    ABot

    Posted 2015-08-28T12:23:59.027

    Reputation: 163

    57 bytes – ASCII-only – 2017-08-19T11:06:16.550

    1

    HTML & JS (w/ jQuery), 85 bytes

    <b><script src="//code.jquery.com/jquery.min.js"><script>$("b").html("Hello, World!")
    

    ABot

    Posted 2015-08-28T12:23:59.027

    Reputation: 163

    1

    Caker, 294 bytes

    ωΩθΩθθΩθΩθθθΘΩθθΩθθΩθΩθΩθΘθθΩθΩθθΩθθΘΩθθΩθΩθθΩθθΘΩθθΩθΩθθθθΘθΩθΩθθΩθθΘΩθΩθθθθθΘΩθΩθΩθΩθΩθθθΘθθΩθΩθθθθΘθθθΩθθΩθΩθΘΩθθΩθΩθθΩθθΘΩθθΩθθΩθΩθθΘΩθΩθθθθΩθΘ
    

    Looks like alot of zeros...

    ABot

    Posted 2015-08-28T12:23:59.027

    Reputation: 163

    1

    Beatnik, 246 bytes

    If pizza zas zas zas zas zas zas my my zas if do key jo my zas if a my jo zas if kid my zas jo jo if za my jo zas if zapper my jo zas if had my jo zas zas my my zas if zas my jo my zas if za my jo zas if zap my jo zas if hip my jo jo if hip my jo
    

    I know, someone else already posted a shorter Beatnik answer using invalid words, but this one uses only valid scrabble words.

    ppperry

    Posted 2015-08-28T12:23:59.027

    Reputation: 3 052

    1

    AsciiDots, 18 bytes

    .-$"Hello, World!"
    

    Try it online!

    user31415

    Posted 2015-08-28T12:23:59.027

    Reputation: 121

    1

    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
    

    Esolanging Fruit

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 495

    1

    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

    Josh

    Posted 2015-08-28T12:23:59.027

    Reputation: 617

    1

    PATH, 113 bytes

    /++}+++++++}+++++}<$+++++++<
    \+}++}++++++{{{{{-^}++.}+++.+++++++..+++.}++.}++++.}+++.{{{.+++.------.--------.}}+.
    

    Try it online!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    BrainFlump, 362 bytes

    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++:..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.;.--------.-------------------------------------------------------------------.
    

    Try it online!

    Should be shorter once we fix loops, but that's it for now.

    Mayube

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 938

    1

    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!

    MD XF

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 337

    1

    Nhohnhehr, 181 bytes

    +-----------+
    |$010010000\|
    |1100101011\|
    |0110001101\|
    |1000110111\|
    |1001011000\|
    |0100000010\|
    |1011101101\|
    |1110111001\|
    |0011011000\|
    |1100100001\|
    |00001  @  \|
    +-----------+
    

    Try it online!

    Erik the Outgolfer

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 165

    1

    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.

    Potato44

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 425

    1

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

    Stephen Leppik

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 178

    1

    Verbosity, 382 bytes

    Include<Integer>
    Include<MetaFunctions>
    Include<Output>
    Include<String>
    Integer:DefineVariable<o;1>
    Output:DefineVariable<P;0>
    String:DefineVariable<s;"Hello, World!">
    String:RedefineVariable<s;String:RemoveCharactersFromStart<s;o>>
    String:RedefineVariable<s;String:TakeFirstCharacters<s;o>>
    Output:DisplayAsText<P;s>
    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?

    caird coinheringaahing

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 705

    I'm somewhat impressed at how it manages to error out on all my attempts to "obviously" shorten it. – Ørjan Johansen – 2017-12-06T01:21:53.387

    1

    LLVM IR, 110 bytes

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

    Try it online!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    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!

    Doorknob

    Posted 2015-08-28T12:23:59.027

    Reputation: 49 044

    1

    Pyt, 40 bytes

    89*2ᴇ⁺Đ7+ĐĐ3+7²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')
                  7²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!

    mudkip201

    Posted 2015-08-28T12:23:59.027

    Reputation: 655

    1

    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

    tfbninja

    Posted 2015-08-28T12:23:59.027

    Reputation: 1

    1

    ELVM-IR, 116 bytes

    putc 72
    putc 101
    putc 108
    putc 108
    putc 111
    putc 44
    putc 32
    putc 87
    putc 111
    putc 114
    putc 108
    putc 100
    putc 33
    exit
    

    Try it online!

    Background

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

    Try it online!

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

    Try it online!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    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.

    moonheart08

    Posted 2015-08-28T12:23:59.027

    Reputation: 361

    1

    This has already been done, and with less bytes (actually, it's the exact same submission, but you miscounted here).

    – Esolanging Fruit – 2018-02-02T16:32:37.777

    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) – moonheart08 – 2018-02-02T16:51:41.520

    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.) – Ørjan Johansen – 2018-02-02T17:29:31.393

    2

    @ØrjanJohansen Searching for "Rust" answers on this question seems to work.

    – Esolanging Fruit – 2018-02-02T19:38:49.483

    1

    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.

    moonheart08

    Posted 2015-08-28T12:23:59.027

    Reputation: 361

    The link is a 404. I'd score the length of the resulting machine code, if that's a thing. – NieDzejkob – 2018-02-08T15:35:07.390

    I'll try and get the length. I'll also fix the link. – moonheart08 – 2018-02-08T15:36:02.507

    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. – moonheart08 – 2018-02-08T15:40:25.577

    1

    Crayon, 16 Bytes

    "Hello, World!"q
    

    Try it online!

    Wurlitzer

    Posted 2015-08-28T12:23:59.027

    Reputation: 79

    2Welcome to PPCG! – Martin Ender – 2018-02-12T12:07:33.040

    1

    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.

    Esolanging Fruit

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 495

    1

    Stax, 8 bytes

    èï┬▀↨╩4G
    

    Run and debug online!

    Explanation

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

    Weijun Zhou

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 214

    1

    Pepe, 122 bytes (39 compressed)

    Pepe is my brand new programming language, which is horrible.

    Normal (122 bytes):

    reeEeeEeeereeEEeeEeErEeEEeEEeereeereeereeEEeEEEEreeeEeEEeereeeEeeeeereeEeEeEEEreeEEeEEEEreeEEEeeEereeereeEEeeEeereeeEeeeeE
    

    Compressed (39 bytes):

    zgozhizp1z8z8zhszfvzfjzh4zhszhvz8zhhzfk
    

    Try them online!

    Probably there are shorter solutions, but that's not task for my brain .-.

    This solution is quite simple, but better to explain it ungolfed:

    reeEeeEeee reeEEeeEeE rEeEEeEEee reee reee reeEEeEEEE reeeEeEEee reeeEeeeee
    reeEeEeEEE reeEEeEEEE reeEEEeeEe reee reeEEeeEee reeeEeeeeE
    

    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.

    Soaku

    Posted 2015-08-28T12:23:59.027

    Reputation: 377

    1

    Dirty, 16 bytes

    'Hello, World!'‼
    

    Try it online!

    Οurous

    Posted 2015-08-28T12:23:59.027

    Reputation: 4 083

    1

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

    Beta Decay

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 590

    1

    F#, 21 bytes

    printf"Hello, World!"
    

    Thanks for the comment @LegionMammal978!

    oopbase

    Posted 2015-08-28T12:23:59.027

    Reputation: 342

    5This can be shortened to printf"Hello, World!" for a 21-byte solution. – LegionMammal978 – 2015-08-31T11:07:35.733

    1

    C++, 59 bytes

    #include <iostream>
    int main(){std::cout<<"Hello, World!";}
    

    TheNumberOne

    Posted 2015-08-28T12:23:59.027

    Reputation: 9 230

    Isn't the newline optional? – jrich – 2015-08-28T14:14:28.267

    @UndefinedFunction try it. It will not work without a new line – georgeunix – 2015-08-28T17:36:57.207

    Isn't printf smaller? #include &lt;cstdio&gt;? – georgeunix – 2015-08-28T17:37:20.957

    1@georgeunix My comment referred to a previous version, in which it read cout&lt;&lt;"Hello, World!\n". The \n was removed, since a newline was not required after the output. – jrich – 2015-08-28T17:39:07.183

    Oh OK, sorry for that @UndefinedFunction – georgeunix – 2015-08-28T17:39:53.793

    @LegionMammal978 no – TheNumberOne – 2015-09-01T22:18:35.070

    1

    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
    

    Kade

    Posted 2015-08-28T12:23:59.027

    Reputation: 6 148

    1

    STATA, 17 bytes

    di"Hello, World!"
    

    bmarks

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 104

    1

    VBA, 16

    ?"Hello, World!"
    

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

    edc65

    Posted 2015-08-28T12:23:59.027

    Reputation: 30 267

    I see. I'll try Brandy – Beta Decay – 2015-08-28T15:01:13.407

    Nope, returns with "Type mismatch: number wanted" – Beta Decay – 2015-08-28T15:01:50.740

    @BetaDecay I can post a screenshot if you like – Jerry Jeremiah – 2015-08-30T23:05:12.833

    1

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

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    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.

    Luis Mendo

    Posted 2015-08-28T12:23:59.027

    Reputation: 68 100

    1disp"Hello, World!" is shorter. – kvill – 2015-08-28T15:44:24.033

    1@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 – Luis Mendo – 2015-08-28T15:49:11.680

    Hm, I thought they shared more syntax and I had no matlab available for testing. Good to know! – kvill – 2015-08-28T20:17:47.297

    1

    dc, 16 bytes

    [Hello, World!]p
    

    I can't think of any way to get this one shorter.

    Digital Trauma

    Posted 2015-08-28T12:23:59.027

    Reputation: 55 069

    1

    Element, 17 bytes

    Hello\,\ World\!`
    

    The ` outputs the string, while the \s are used to escape out of other characters.

    PhiNotPi

    Posted 2015-08-28T12:23:59.027

    Reputation: 18 585

    1

    FALSE, 15 bytes

    "Hello, World!"
    

    Rohcana

    Posted 2015-08-28T12:23:59.027

    Reputation: 200

    1

    Vimscript, 17 bytes

    ec"Hello, World!"
    

    Kamehameha

    Posted 2015-08-28T12:23:59.027

    Reputation: 553

    You can remove the colon to save one byte ;) – wefwefa3 – 2015-08-30T20:32:53.053

    @ryvnf Thanks :) – Kamehameha – 2015-08-31T05:10:14.913

    1

    Io, 21 bytes

    "Hello, World!" write
    

    georgeunix

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 573

    This Io (TIO) seems to have print, but not write. Is this another language with the same name? – Dennis – 2018-02-11T15:40:41.017

    1

    Objective-C, 30 bytes

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

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    1

    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.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    1

    Curry, 26 bytes

    main=putStr"Hello, World!"
    

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    1

    Clojure, 22 bytes

    (print"Hello, World!")
    

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    1

    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.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    Yes, otherwise Burlesque will add "". – Lynn – 2015-10-23T21:25:05.460

    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. – Lynn – 2015-10-23T21:46:37.537

    1

    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.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    1

    K, 18 bytes

    `0:"Hello, World!"
    

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    I think you should try for every letter in the alphabet ;) – Beta Decay – 2015-08-28T18:22:39.620

    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). – refi64 – 2015-09-02T02:28:31.313

    1

    Frink, 23 bytes

    println["Hello, World"]
    

    I only know of this through my searches for programming apps in the Play Store.

    Beta Decay

    Posted 2015-08-28T12:23:59.027

    Reputation: 11 590

    1

    TvmJIT, 29 bytes

    (!call print "Hello, World!")
    

    refi64

    Posted 2015-08-28T12:23:59.027

    Reputation: 7 567

    1

    awk, 25 bytes

    END{print"Hello, World!"}
    

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    I know little of awk, but I think you can remove the END part. (It's June I know). – Erik the Outgolfer – 2016-06-02T19:30:19.457

    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. :( – Robert Benson – 2016-07-19T13:11:17.083

    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. – user3710044 – 2017-03-19T08:53:50.060

    1

    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.

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    1

    Dart, 31 bytes

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

    Lynn

    Posted 2015-08-28T12:23:59.027

    Reputation: 41 980

    1

    Gema, 21 bytes

    \A=Hello, World\!@end
    

    (Without input it would wait forever without terminating. Hence the need for explicitly @end.)

    manatwork

    Posted 2015-08-28T12:23:59.027

    Reputation: 15 670

    1

    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.

    curiousdannii

    Posted 2015-08-28T12:23:59.027

    Reputation: 602

    1

    Muriel, 16 bytes

    ."Hello, World!"
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    O, 16 bytes

    "Hello, World!"o
    

    Try it online in the O Online IDE.

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

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

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    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 
    

    MickyT

    Posted 2015-08-28T12:23:59.027

    Reputation: 9 062

    1

    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.

    智障的人

    Posted 2015-08-28T12:23:59.027

    Reputation: 111

    It seems we already have a shorter LOLCODE answer (feel free to leave yours as well though if you want).

    – Martin Ender – 2015-08-29T22:34:09.290

    1Ah - ok. I'll leave mine here for the purpose of having HAI and KTHXBYE. – 智障的人 – 2015-08-29T22:35:20.997

    1

    ~English revised, 21 bytes

    Show "Hello, World!".
    

    ~English is not English, but looks like it.

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    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!
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    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.

    user42003

    Posted 2015-08-28T12:23:59.027

    Reputation:

    1

    MoonScript, 20 bytes

    print"Hello, World!"
    

    manatwork

    Posted 2015-08-28T12:23:59.027

    Reputation: 15 670

    1

    BrainfuckXT, 16 bytes

    {Hello, World!}$
    

    {...} puts a string on the tape, and $ outputs it.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    PureStack, 18 bytes

    "Hello, World!"
    !~
    

    Pushes "Hello, World!" to the stack and prints it.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    Kipple, 67 17 bytes

    "Hello, World!">o
    

    Sends the string to o using the preprocessor.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    Loader, 22 bytes

    printf "Hello, World!"
    

    SuperJedi224

    Posted 2015-08-28T12:23:59.027

    Reputation: 9 433

    1

    Microscript, 17 bytes

    "!dlroW ,olleH"ah
    

    SuperJedi224

    Posted 2015-08-28T12:23:59.027

    Reputation: 9 433

    1

    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.

    ASCIIThenANSI

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 677

    1

    Staq, 15 bytes

    "Hello, World!"
    

    Output:

    Executing D:\codegolf\Staq Hello World codegolf.txt
    
    Hello, World!
    
    Execution complete.
    >
    

    M L

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 445

    1

    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.

    Screenshot

    refi64

    Posted 2015-08-28T12:23:59.027

    Reputation: 7 567

    1

    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.
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 162 549

    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 – 2015-09-03T00:08:51.253

    @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. – Martin Ender – 2015-09-03T00:11:30.093

    @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. – Martin Ender – 2015-09-03T12:05:56.053

    That makes sense – MickyT – 2015-09-03T18:47:42.703

    1

    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.

    Martin Ender

    Posted 2015-08-28T12:23:59.027

    Reputation: 162 549

    1

    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
    

    MickyT

    Posted 2015-08-28T12:23:59.027

    Reputation: 9 062

    1

    ISCOM, 15 bytes

    "Hello, World!"
    

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    KimL, 22 bytes

    io.out"Hello, World!"
    

    The byte count contains a trailing linefeed.

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    Basil, 16 bytes

    Meh.

    "Hello, World!"o
    

    Simple.

    The_Basset_Hound

    Posted 2015-08-28T12:23:59.027

    Reputation: 1 121

    1

    OCaml, 30 bytes

    print_string "Hello, World!";;
    

    helencrump

    Posted 2015-08-28T12:23:59.027

    Reputation: 161

    1print_string"Hello, World!" also works, for 27 bytes. Try it online! – Dennis – 2018-01-26T01:11:33.337

    1

    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

    Jacob Misirian

    Posted 2015-08-28T12:23:59.027

    Reputation: 632

    Using your online interpreter you can shorten it a bit using func main()println("Hello, World!") – MickyT – 2015-09-19T07:03:38.103

    1

    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.

    Ismael Miguel

    Posted 2015-08-28T12:23:59.027

    Reputation: 5 787

    1

    Aeolbonn, 14 bytes

    :Hello, World!
    

    : is the standard output mechanism.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    Amiga E, 38 bytes

    PROC main() IS WriteF('Hello, World!')
    

    WriteF is the standard output mechanism.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    96, 44 bytes

    72,101,108:,@,111,44,32,87,111,114,@,100,33"
    

    Uses the accumulator to store the L.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    Sprects, 14 bytes

    .Hello, World!
    

    DanTheMan

    Posted 2015-08-28T12:23:59.027

    Reputation: 2 490

    1

    MUMPS, 17 bytes

    w "Hello, World!"
    

    Not terribly exciting, but there you have it.

    senshin

    Posted 2015-08-28T12:23:59.027

    Reputation: 611

    http://i.imgur.com/RG0BS1U.gif – DanTheMan – 2015-09-28T04:01:44.703

    1

    A:;, 19 bytes

    b:Hello, World!;p:b
    

    Sets b to the string and prints it.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    Thue, 24 bytes

    a::=~Hello, World!
    ::=
    a
    

    When a is encountered in the last line, the string is printed.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    ABCD, 390 bytes

    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAADDAAADBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBDBBBBBBBBBBBBDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAADAAADBBBBBBDBBBBBBBBDBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBDBBBBBBBBBBBBBBBBBBBBBBBD
    

    Equivalent to +++++etc+++.+++++etc+++.+++++++..+++.-----etc in brainfuck.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    Dogless, 13 bytes

    Hello, World!
    

    There is no |, so the program just terminates and outputs itself.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    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.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    UniBasic, 19 Bytes

    CRT 'Hello, World!'
    

    Ken Gregory

    Posted 2015-08-28T12:23:59.027

    Reputation: 151

    1

    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.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    EXCON, 137 bytes

    <<<^<<<^!:^<<^<<<^<^!:<<^<^<<^<^!!:^<^<^<^<<^<^!:<<^<^<<^!:<<<<<^!:^<^<^<<^<<^!:^<^<^<^<<^<^!:<^<<<^<^<^!:<<^<^<<^<^!:<<^<<<^<^!:^<<<<<^!
    

    Simple bit-hacking.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    Stackstack, 21 bytes

    "Hello, World!" print
    

    print is the standard output mechanism.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    Processing, 23 bytes

    print("Hello, World!");
    


    Well, that's pretty much it!

    Cows quack

    Posted 2015-08-28T12:23:59.027

    Reputation: 12 883

    1

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

    manatwork

    Posted 2015-08-28T12:23:59.027

    Reputation: 15 670

    1

    G*, 15 bytes

    p Hello, World!
    

    Pretty simple.

    m654

    Posted 2015-08-28T12:23:59.027

    Reputation: 636

    1

    Augeas, 42 bytes

    module A=let _=print_string"Hello, World!"
    

    I'm writing this because ℝaphink won't.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    If it got someone else to post an Augeas answer, I'm happy with that :-) – ℝaphink – 2015-10-14T05:08:50.810

    1

    Stringy, 17 bytes

    (Hello, World!);p
    

    m654

    Posted 2015-08-28T12:23:59.027

    Reputation: 636

    1

    Pip, 15 bytes

    "Hello, World!"
    

    Straightforward. Any expression at the end of the program is auto-printed.

    DLosc

    Posted 2015-08-28T12:23:59.027

    Reputation: 17 064

    Out of curiosity, dose Pip have auto-closing end quotes? Or is that impractical for an infix language? – Conor O'Brien – 2016-09-16T01:23:30.590

    @ConorO'Brien It would certainly have been possible, I just decided I didn't like it for aesthetic reasons. – DLosc – 2016-09-16T03:06:24.477

    Fair enough. :D – Conor O'Brien – 2016-09-16T03:06:53.477

    1

    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.
    

    DJgamer98

    Posted 2015-08-28T12:23:59.027

    Reputation: 419

    1

    , 19 17 bytes

    ô`Hello, World!`
    

    The “” string construction actually ends up using more bytes.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1Yay, someone else is using my language! You can do ô\Hello, world`` too. – Mama Fun Roll – 2015-11-02T00:08:47.153

    1

    Chaîne, 13 bytes

    Hello, World!
    

    Everything is an implicit string, and everything is implicit output.

    Conor O'Brien

    Posted 2015-08-28T12:23:59.027

    Reputation: 25 859

    1Ooh, fancy i-like character~ Also an interesting language. – Addison Crump – 2015-11-01T18:12:17.047

    1

    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!

    Dennis

    Posted 2015-08-28T12:23:59.027

    Reputation: 171 923

    1

    Microscript II, 15 bytes

    "Hello, World!"
    

    SuperJedi224

    Posted 2015-08-28T12:23:59.027

    Reputation: 9 433

    1

    SuperCollider, 27 bytes

    "Hello, World!".post;1.exit
    

    quartata

    Posted 2015-08-28T12:23:59.027

    Reputation: 8 270

    Where is the documentation for SuperCollider? – user48538 – 2016-01-11T04:42:13.453

    @zyabin101 http://supercollider.github.io/

    – quartata – 2016-01-11T15:53:36.690

    It's not an esolang. – quartata – 2016-01-11T15:53:43.647

    1

    Geom++, 17 bytes

    " Hello, World! "
    

    Yes, the spaces around the string are necessary.

    LegionMammal978

    Posted 2015-08-28T12:23:59.027

    Reputation: 14 318

    1

    DStack, 21 bytes

    @0
    Hello, World!
    @
    ad
    

    DarkPhantom

    Posted 2015-08-28T12:23:59.027

    Reputation: 191

    1</