451
\$\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 quit because SE is EVIL 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
  • 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\$ – 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

800 Answers 800

1
12 13
14
15 16
27
2
\$\begingroup\$

DOG, 20 bytes

bark "Hello, World!"
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

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

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

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
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ like the theme lol \$\endgroup\$ – Rohan Jhunjhunwala Sep 16 '16 at 1:16
2
\$\begingroup\$

Cow, 1539 Bytes

MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO MoO MoO MoO MoO MoO Moo Moo MoO MoO MoO Moo OOO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo Moo MOo MOo MOo MOo MOo MOo MOo MOo Moo MoO MoO MoO Moo MOo MOo MOo MOo MOo MOo Moo MOo MOo MOo MOo MOo MOo MOo MOo Moo OOO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ ...I count 1539 bytes. \$\endgroup\$ – Conor O'Brien Jul 24 '16 at 15:40
  • \$\begingroup\$ What? O.o I don't. \$\endgroup\$ – Ronronner Jul 24 '16 at 16:34
  • \$\begingroup\$ Well, unless this is in a special encoding, there are 1539 characters thus 1539 bytes. \$\endgroup\$ – Conor O'Brien Jul 24 '16 at 16:39
  • \$\begingroup\$ I've correct it. \$\endgroup\$ – Ronronner Jul 24 '16 at 17:01
  • 1
    \$\begingroup\$ 261 bytes, which is a trivial variant of the brainfuck solution. I'm sure COW can do better, I just don't know what methods could be used to beat recurrence relations \$\endgroup\$ – ASCII-only Jul 27 '17 at 23:51
2
\$\begingroup\$

Jellyfish, 15 bytes

P"Hello, World!

Try it online!

Not terribly interesting, but for completeness' sake...

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

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
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ -1 language name makes me want cake :P \$\endgroup\$ – Downgoat Aug 15 '16 at 19:54
2
\$\begingroup\$

Ru, 15 bytes

“Hello, World!”

Body must be at least 30 characters; you entered 29.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

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

print Hello, World!

Seems legit!

| improve this answer | |
\$\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).

| improve this answer | |
\$\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.

| improve this answer | |
\$\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.

| improve this answer | |
\$\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!

| improve this answer | |
\$\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"
| improve this answer | |
\$\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.
| improve this answer | |
\$\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
| improve this answer | |
\$\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 ".

| improve this answer | |
\$\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!

| improve this answer | |
\$\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
  • 1
    \$\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‹
| improve this answer | |
\$\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!

| improve this answer | |
\$\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.

| improve this answer | |
\$\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.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Samau, 15 bytes

"Hello, World!"

Samau is yet another stack-based golfing language.

| improve this answer | |
\$\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)

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Turing, 18 bytes

put"Hello, World!"
| improve this answer | |
\$\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.

| improve this answer | |
\$\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  ~##~~#~~@*
!  ~~#~~~~#@*
| improve this answer | |
\$\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).

| improve this answer | |
\$\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!"
| improve this answer | |
\$\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.

| improve this answer | |
\$\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.

| improve this answer | |
\$\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
1
12 13
14
15 16
27

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.