423
\$\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\$
  • 2
    \$\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\$ – Martin Ender Aug 28 '15 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\$ – aditsu Aug 28 '15 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\$ – Martin Ender Aug 28 '15 at 19:34
  • 7
    \$\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\$ – Martin Ender Aug 29 '15 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\$ – user202729 May 20 '18 at 10:20

759 Answers 759

2
\$\begingroup\$

S.I.L.O.S, 19 bytes

print Hello, World!

Seems legit!

\$\endgroup\$
  • 2
    \$\begingroup\$ This is a 19 bytes. \$\endgroup\$ – Conor O'Brien Sep 16 '16 at 0:00
  • \$\begingroup\$ @ConorO'Brien whops, I can progam, but I can't count to 19.... :( \$\endgroup\$ – Rohan Jhunjhunwala Sep 16 '16 at 1:13
  • 4
    \$\begingroup\$ Ironic... the nineteenth byte ;) \$\endgroup\$ – Conor O'Brien Sep 16 '16 at 1:22
2
\$\begingroup\$

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

\$\endgroup\$
  • 1
    \$\begingroup\$ This prints Hmllo,World on TIO. \$\endgroup\$ – Dennis Dec 3 '16 at 0:51
2
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ remove the AND's for more golfing \$\endgroup\$ – Rohan Jhunjhunwala Sep 25 '16 at 1:22
2
\$\begingroup\$

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.

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

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!

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

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"
\$\endgroup\$
  • \$\begingroup\$ There's a 174 byte one on TIO \$\endgroup\$ – ASCII-only Aug 21 '17 at 12:16
2
\$\begingroup\$

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.
\$\endgroup\$
2
\$\begingroup\$

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

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

\$\endgroup\$
  • \$\begingroup\$ It's supposed to print an uppercase W (even though it's in the middle of the sentence...) \$\endgroup\$ – 12Me21 Feb 1 '17 at 20:49
2
\$\begingroup\$

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!

\$\endgroup\$
  • \$\begingroup\$ 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. \$\endgroup\$ – Engineer Toast Mar 22 '17 at 19:28
  • \$\begingroup\$ @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. \$\endgroup\$ – Erik the Outgolfer Mar 23 '17 at 12:43
  • \$\begingroup\$ 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. \$\endgroup\$ – Engineer Toast Mar 23 '17 at 22:47
  • \$\begingroup\$ You can remove the space after the quote \$\endgroup\$ – ASCII-only Aug 23 '17 at 6:55
2
\$\begingroup\$

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‹
\$\endgroup\$
  • 2
    \$\begingroup\$ Nope. It's 17 bytes. \$\endgroup\$ – TuxCrafting Feb 4 '17 at 22:43
  • 2
    \$\begingroup\$ No, not 13 bytes. 17 bytes. The interpreter recieves a file as UTF-8 bytes, of which there are 17, it doesn't matter how it tokenises those bytes. This is opposed to, e.g. TI-Basic which has a character encoding that really does represent multiple characters with one bytes. \$\endgroup\$ – Pavel Feb 4 '17 at 22:44
  • \$\begingroup\$ Oh. Didn't realise it worked that way, I'll change it. \$\endgroup\$ – user63571 Feb 4 '17 at 22:44
  • \$\begingroup\$ Also why downvote simply because I didn't understand string encoding? Seems a little mean. \$\endgroup\$ – user63571 Feb 4 '17 at 22:47
  • \$\begingroup\$ @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? \$\endgroup\$ – Pavel Feb 4 '17 at 23:11
2
\$\begingroup\$

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!

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

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.

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

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.

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

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.

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

Samau, 15 bytes

"Hello, World!"

Samau is yet another stack-based golfing language.

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

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.

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

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)

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

Turing, 18 bytes

put"Hello, World!"
\$\endgroup\$
2
\$\begingroup\$

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.

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

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  ~##~~#~~@*
!  ~~#~~~~#@*
\$\endgroup\$
  • \$\begingroup\$ Fantastic job!! \$\endgroup\$ – Conor O'Brien Mar 2 '16 at 19:37
  • \$\begingroup\$ ::**==:*:*. \$\endgroup\$ – CalculatorFeline Mar 25 '16 at 23:48
  • \$\begingroup\$ @CalculatorFeline Yeah, it can be either way. \$\endgroup\$ – ETHproductions Sep 7 '16 at 2:25
2
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ 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" \$\endgroup\$ – Shaun Bebbers Feb 13 '17 at 9:07
  • 2
    \$\begingroup\$ Somehow I could 22 bytes in the basic solution, also 0?"HELLO, WORLD!" should work for 17 bytes. \$\endgroup\$ – NieDzejkob Apr 29 '17 at 17:25
  • 1
    \$\begingroup\$ You know, you don't actually have to include the line numbers for the program to work. PRINT"HELLO, WORLD!" for 20 bytes will do fine. \$\endgroup\$ – MD XF May 7 '17 at 21:28
  • 1
    \$\begingroup\$ Also, if Commodore 64 BASIC is like most old BASIC implementations (which I'm pretty sure it is) you could leave off the ending quote altogether. \$\endgroup\$ – MD XF May 7 '17 at 21:29
  • \$\begingroup\$ @NieDzejkob - using Commodore BASIC abbreviations does not save any bytes in the computer, it only saves typing. \$\endgroup\$ – Shaun Bebbers May 8 '17 at 14:43
2
\$\begingroup\$

SASS, 32 bytes?

\:after
  content:"Hello, World!"
\$\endgroup\$
2
\$\begingroup\$

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.

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

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.

\$\endgroup\$
  • 4
    \$\begingroup\$ 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). \$\endgroup\$ – Okx May 19 '17 at 6:18
2
\$\begingroup\$

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

;#

Interpreter provided by @ETHProductions

Read this for a full list of commands.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
\$\endgroup\$
  • \$\begingroup\$ Sorry, not a language :( \$\endgroup\$ – Esolanging Fruit Jun 4 '17 at 6:47
  • \$\begingroup\$ @Challenger5 kolmogorov-complexity challenge. Doesn't have to be \$\endgroup\$ – caird coinheringaahing Jun 4 '17 at 11:51
  • \$\begingroup\$ Oh yeah, that's true. Never mind. \$\endgroup\$ – Esolanging Fruit Jun 4 '17 at 15:50
2
\$\begingroup\$

Fishing, 25 24 bytes

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

It exits with an error.

Fishing, 34 bytes

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

Without errors.

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

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.

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

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.

\$\endgroup\$

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.