503
\$\begingroup\$

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

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

The Rules

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

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

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

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

For inspiration, check the Hello World Collection.

The Catalogue

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

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

## Language Name, N bytes

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

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

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

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

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

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

/* Configuration */

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

/* App */

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

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

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

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

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

getAnswers();

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

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

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

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

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

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

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

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

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

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

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

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

table thead {
  font-weight: bold;
}

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

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

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

\$\endgroup\$
21
  • 3
    \$\begingroup\$ @isaacg No it doesn't. I think there would be some interesting languages where it's not obvious whether primality testing is possible. \$\endgroup\$ Aug 28, 2015 at 13:56
  • 6
    \$\begingroup\$ If the same program, such as "Hello, World!", is the shortest in many different and unrelated languages, should it be posted separately? \$\endgroup\$ Aug 28, 2015 at 15:33
  • 2
    \$\begingroup\$ @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. \$\endgroup\$ Aug 28, 2015 at 19:34
  • 8
    \$\begingroup\$ @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. \$\endgroup\$ Aug 29, 2015 at 23:01
  • 2
    \$\begingroup\$ @MartinEnder ... Almost. If two BF solutions have the same size, the one with smaller lexicographical order will take smaller number of bytes in Unary. Of course the smallest Unary solution translated to BF is guaranteed to be smallest. \$\endgroup\$
    – DELETE_ME
    May 20, 2018 at 10:20

932 Answers 932

1
3 4
5
6 7
32
7
\$\begingroup\$

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.

\$\endgroup\$
7
\$\begingroup\$

MATL, 15 bytes

'Hello, World!'

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

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Is it finished? Congratz! Looking forward to seeing it in use. I'll hopefully have the chance to check it out one day :-) \$\endgroup\$ Dec 12, 2015 at 17:09
  • 1
    \$\begingroup\$ @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! \$\endgroup\$
    – Luis Mendo
    Dec 12, 2015 at 17:13
7
\$\begingroup\$

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

\$\endgroup\$
7
\$\begingroup\$

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!");}}
\$\endgroup\$
4
  • 1
    \$\begingroup\$ FREAKING FINALLY! Suggestion: Add a piece of code that completes quotes, parens, and } <-- those so you can omit the last four chars. (Maybe a little AIS could help here?) \$\endgroup\$ Jan 3, 2016 at 17:46
  • \$\begingroup\$ Java for golf, but there's STILL a freakin' semicolon! \$\endgroup\$
    – cat
    Jan 3, 2016 at 18:21
  • \$\begingroup\$ @cat yeah, I know. Me and Conor are trying to figure out how to avoid having to use it. \$\endgroup\$
    – GamrCorps
    Jan 3, 2016 at 18:22
  • 3
    \$\begingroup\$ @cat well, Glava 1.2+ supports semicolon insertion before closing curly brackets, so it fixes that problem \$\endgroup\$
    – GamrCorps
    Jan 4, 2016 at 16:38
7
\$\begingroup\$

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

\$\endgroup\$
2
  • 3
    \$\begingroup\$ My only words are "O_o" \$\endgroup\$
    – Downgoat
    Mar 15, 2016 at 2:46
  • \$\begingroup\$ @Downgoat Then I have done my job. \$\endgroup\$ Mar 15, 2016 at 2:50
7
\$\begingroup\$

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 '!'.
\$\endgroup\$
2
  • \$\begingroup\$ How does this end up being shorter than the trivial solution when assembled? codegolf.stackexchange.com/a/86567/34718 \$\endgroup\$
    – mbomb007
    Jul 25, 2016 at 19:39
  • \$\begingroup\$ Because the arguments to add and sub are considerably smaller. Arguments are encoded in bijective binary, and each digit requires 3 bits. \$\endgroup\$
    – Dennis
    Jul 25, 2016 at 19:42
7
\$\begingroup\$

Haskell, 26 bytes

main=putStr"Hello, World!"

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ Putting one of the many compilers you downloaded for PLQ to good use I see. ;) \$\endgroup\$
    – Alex A.
    Aug 28, 2015 at 16:52
7
\$\begingroup\$

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!

\$\endgroup\$
7
\$\begingroup\$

Mind, 26 bytes

The program is encoded in Shift_JIS:

メインは
"Hello, World!"
表示

It means something like:

MAIN is:
"Hello, World!"
display

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

\$\endgroup\$
7
+250
\$\begingroup\$

Grass, 463 446 bytes

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

wWWWwWWWWwWWWWWwvwwWWwWWWwvWwWwwwwwWWWwWWWwWWWWWwvwWWwwwwwwwwwwwWWWwWWWWWwWWWWwvwWWwwwwwWWWWWWWWWWWWwWWWwvWwwwwwwwwwwwWWwwwwwwWWWWWWWWwWWWWWWWwwWWWWWWwwwwwwwvwWWWWWWWwwwwwwwwwWWWWWWWWWWWWWwWWWwvWwwwwwwwwwwwwwwwwwWWwwwwwwwwwwwwWWWWWWWWWWWWWWWWWwvwWwWwwwwwwwwWwwwwwwWwwwwwwWwwwwwwwWwwwwwwwWwwwwwwwwwwwwwwWWWWWWWWWWWWWWWWWWwvwwWWWWWWWWWWWWWWWWWWWWWWwWWWwwwvWWwWWWWWWWWWWWWWWWWWWWWWwwwwWWwwwwwwwwwWwwwwwwWwwwWwwwwwwwwwWWWWWWWWWWWWwWwwwwwwwwwwwwwwwwww

Try it online!

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

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

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

\$\endgroup\$
4
  • \$\begingroup\$ :| explanation pls \$\endgroup\$
    – ASCII-only
    Apr 28, 2018 at 2:39
  • \$\begingroup\$ Or even better, convert to this form if you don't mind \$\endgroup\$
    – ASCII-only
    Apr 28, 2018 at 2:43
  • \$\begingroup\$ @ASCII-only Added the link to answer. Not sure it is actually better. \$\endgroup\$
    – jimmy23013
    Apr 28, 2018 at 5:14
  • \$\begingroup\$ Probably not, I just wanted it to add to RosetTIO to make it easier for other people to attempt to golf it (not that anyone will :P) \$\endgroup\$
    – ASCII-only
    Apr 28, 2018 at 6:12
7
\$\begingroup\$

AArch64 machine language Linux, 48 45 bytes

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

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

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

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.

\$\endgroup\$
7
\$\begingroup\$

// TODO: fix, 51 bytes

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

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

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

The language isn't really designed for golfing, but a bit of fiddling with the syntax got this down to 51 bytes. Here is a more "idiomatic" example taken from the language's README:

use std::io::{stdout, Write};
// TODO: someone on the internet told me "Hello, world!" is a good idea
fn hello() {
    let chars = &[
        '\n', '!', 'd', 'l', 'r', 'o', 'w', ' ', ',', 'o', 'l', 'l', 'e', 'H'
    ];
    let mut out = stdout();
    // TODO: somehow fix this cursed code
    for c in chars.iter().rev() {
        let mut buf = vec![0; 4];
        c.encode_utf8(&mut buf).unwrap();
        out.write(&buf).unwrap();
    }
    out.flush.expect("unwrap");
}

(the language simply ignores everything except the TODOs)

\$\endgroup\$
7
\$\begingroup\$

Risky, 64 bytes

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

Try it online!

This is a new language made by @Radvylf. My explanation wouldn't do it justice so heres the Docs.

Explanation:

Takes the various codepoints for various characters and links them together.

Redwolf also created a version of it which is a simpler "tree" layout, which also comes in at 64 bytes:

**}+1+1!0+:+0+1+0+:+0++!0+:+0+++0+:+!++!{**+0+{+!**+0+2!+**+0+}+0+:+!++!:+*+0+{+0+:+0++!0+0+0+:+!**+0+!20+0+0+]+0+0+0+]+0+0+0+]

Try it online!

\$\endgroup\$
7
\$\begingroup\$

Cubestack, 65 bytes

S R2 R R2 f2 r R r R r r R' L2 R B2 R2 u r r r L r R R2 f' R b S'

Try it online!

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

\$\endgroup\$
2
7
\$\begingroup\$

Positionally, 394 bytes

/           > \


  -
>    "!dlrow!" v
        v      <

   v  \ \   ^

  1


      
   ~

  ^           /
  <   \



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

   < >  \
      \

Try It Online!

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

\$\endgroup\$
6
\$\begingroup\$

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.

\$\endgroup\$
6
\$\begingroup\$

Pascal, 32 bytes

begin write('Hello, World!')end.
\$\endgroup\$
6
\$\begingroup\$

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                        
\$\endgroup\$
2
  • \$\begingroup\$ Can you add Scrabble scores to the explanation? \$\endgroup\$ Jun 5, 2017 at 4:34
  • \$\begingroup\$ The version using valid scrabble words is only 100 bytes longer. \$\endgroup\$ Aug 2, 2017 at 0:44
6
\$\begingroup\$

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!");}
\$\endgroup\$
11
  • 1
    \$\begingroup\$ With g++, you can eliminate the space on line 1 and the int on line 2. \$\endgroup\$
    – Dennis
    Aug 29, 2015 at 3:56
  • \$\begingroup\$ @Dennis, done. I think this is the shortest possible in C++. \$\endgroup\$
    – DJMcMayhem
    Aug 29, 2015 at 7:02
  • 4
    \$\begingroup\$ This is not legal C++ code. The return type of main must be int and cannot be empty. \$\endgroup\$
    – Hubi
    Aug 31, 2015 at 9:34
  • 1
    \$\begingroup\$ @DJMcMayhem The fact, that compiler compiles something, does not mean, that it is correct. C++ does not support default int. \$\endgroup\$
    – Zereges
    Oct 25, 2015 at 11:20
  • 1
    \$\begingroup\$ It's 47 bytes, not 48 \$\endgroup\$
    – ASCII-only
    Aug 18, 2017 at 12:14
6
\$\begingroup\$

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
\$\endgroup\$
0
6
\$\begingroup\$

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.

\$\endgroup\$
1
  • 2
    \$\begingroup\$ I know this is way late, but you can loop by having an operation call itself [!dlroW ,olleH]$[/.:!]v*:! \$\endgroup\$
    – BlackCap
    Jul 21, 2017 at 14:57
6
\$\begingroup\$

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.

\$\endgroup\$
6
\$\begingroup\$

Your Mom, 14 bytes

'Hello, World!

Explanation

'...
'... - Push the string. The ending ' is not needed at the end of program
     - Implicit output
\$\endgroup\$
6
\$\begingroup\$

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

\$\endgroup\$
6
  • 1
    \$\begingroup\$ 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) \$\endgroup\$
    – Wheat Wizard
    Sep 6, 2016 at 17:49
  • \$\begingroup\$ You can also change ([]){} to [][]. (try it online) \$\endgroup\$
    – Wheat Wizard
    Sep 6, 2016 at 17:51
  • \$\begingroup\$ @WheatWizard Good tips, thankyou! \$\endgroup\$
    – DJMcMayhem
    Sep 6, 2016 at 17:53
  • \$\begingroup\$ You can change (({})){}([])[](){} to (({}))[]{}[][](). (try it online) \$\endgroup\$
    – Wheat Wizard
    Sep 6, 2016 at 18:11
  • \$\begingroup\$ Ok, two more: try it online \$\endgroup\$
    – Wheat Wizard
    Sep 6, 2016 at 18:19
6
\$\begingroup\$

V, 14 bytes

iHello, World!

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

\$\endgroup\$
6
\$\begingroup\$

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

\$\endgroup\$
3
  • \$\begingroup\$ nice work ... I thought it could be done better \$\endgroup\$
    – MickyT
    Sep 4, 2015 at 1:01
  • \$\begingroup\$ 608 bytes using (define f (lambda (a b) (char (- (* 6 19) (* a 13) b)))) \$\endgroup\$
    – Leaky Nun
    Aug 23, 2017 at 11:00
  • \$\begingroup\$ 604 bytes after golfing Leaky Nun's answer slightly \$\endgroup\$
    – Sherlock9
    Aug 23, 2017 at 13:07
6
\$\begingroup\$

Casio Basic, 15 Bytes

"Hello, World!"

I think it explaines itself well enough...

\$\endgroup\$
3
  • \$\begingroup\$ 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. \$\endgroup\$ May 30, 2017 at 20:16
  • \$\begingroup\$ Thanks and sorry that I messed up the formatting, I'm not really used to yet... \$\endgroup\$
    – ADDB
    May 30, 2017 at 20:17
  • \$\begingroup\$ Perfectly OK! Just use four spaces before code, and a pound sign (#) or two before your header. \$\endgroup\$ May 30, 2017 at 20:18
6
\$\begingroup\$

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

\$\endgroup\$
6
\$\begingroup\$

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.

\$\endgroup\$
2
  • \$\begingroup\$ If anyone wants to try golfing this down some more, they may find this answer on SO and the material it references helpful. \$\endgroup\$
    – 3D1T0R
    May 29, 2018 at 19:53
  • 1
    \$\begingroup\$ github.com/pts/pts-tinype Some smaller Hello World .exes, not mine. I couldn't get the 268-byte ones to run at all, and the 402-byte one would only run with my antivirus shut off. \$\endgroup\$
    – Nnnes
    Jul 23, 2018 at 11:19
1
3 4
5
6 7
32

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.