517
\$\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
  • 4
    \$\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
  • 7
    \$\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

975 Answers 975

1
15 16
17
18 19
33
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\$
1
  • \$\begingroup\$ There's a 174 byte one on TIO \$\endgroup\$
    – ASCII-only
    Aug 21, 2017 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\$
0
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\$
8
  • 2
    \$\begingroup\$ Nope. It's 17 bytes. \$\endgroup\$ Feb 4, 2017 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, 2017 at 22:44
  • \$\begingroup\$ Oh. Didn't realise it worked that way, I'll change it. \$\endgroup\$
    – user63571
    Feb 4, 2017 at 22:44
  • \$\begingroup\$ Also why downvote simply because I didn't understand string encoding? Seems a little mean. \$\endgroup\$
    – user63571
    Feb 4, 2017 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, 2017 at 23:11
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\$

Samau, 15 bytes

"Hello, World!"

Samau is yet another stack-based golfing language.

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

Turing, 18 bytes

put"Hello, World!"
\$\endgroup\$
2
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\$
3
  • \$\begingroup\$ Fantastic job!! \$\endgroup\$ Mar 2, 2016 at 19:37
  • \$\begingroup\$ ::**==:*:*. \$\endgroup\$ Mar 25, 2016 at 23:48
  • \$\begingroup\$ @CalculatorFeline Yeah, it can be either way. \$\endgroup\$ Sep 7, 2016 at 2:25
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\$
1
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\$
1
  • 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, 2017 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\$
0
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\$

Aheui, 147 144 bytes

발따밤따빠받나파빠밣다빠밦다빠받타밢밢따밦다밤밣따밦밦따빠밣다파받따빠받다파빠빠밠타밣밢따아멓희
\$\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\$
2
\$\begingroup\$

Set, 123 bytes

set ! H
set ! 101
set ! 108
set ! 108
set ! 111
set ! 44
set ! 32
set ! 87
set ! 111
set ! 114
set ! 108
set ! 100
set ! 33

Needed to use raw ASCII codes because lowercase letters are reserved for variable names.

Try it online!

\$\endgroup\$
6
  • \$\begingroup\$ Wow, someone actually used this language. I'm both surprised and very happy \$\endgroup\$ Aug 10, 2017 at 1:58
  • 1
    \$\begingroup\$ @MatheusAvellar If you haven't yet noticed it has been used in the largest polyglot in existence. \$\endgroup\$
    – MD XF
    Aug 10, 2017 at 3:55
  • \$\begingroup\$ I had no idea! That's the coolest! Hahaha \$\endgroup\$ Aug 10, 2017 at 9:05
  • \$\begingroup\$ You can use W instead of 87 \$\endgroup\$
    – ASCII-only
    Apr 11, 2018 at 9:13
  • \$\begingroup\$ @ASCII-only but the bytecount is 123 \$\endgroup\$
    – MD XF
    Jun 18, 2018 at 21:22
2
\$\begingroup\$

MY, 60 bytes

27á'←1Aá'←8Aá'2×←1Bá'←44á'←2Ġ'←78á'←1Bá'←4Bá'←8Aá'←AȦ'←33á'←

MY IS ON TIO!!

How?

Outputs H, e, ll, o, <space>, W, o, r, l, d, ! to the console.

I created a 3rd answer to this question due to the differing techniques used, this uses concatenation on numbers (27á pushes 72), one uses increment and decrement, while another uses a builtin.

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

Braingolf, 17 bytes

Got bored, made my own language, here's Hello World

"Hello, World!"&@

Explanation:

"Hello, World!"    Push the 13 chars of Hello World to the stack as charcode integers
               &@  Pop the entire stack and print as chars

Alternatively, here's hello world from before I added multi-char strings and printing:

#!#d#l#r#o#W# #,#o#l#l#e#H@@@@@@@@@@@@@

Explanation:

#!                                 Push the charcode of char '!' to the end of the stack
  ....................             Do this for every character in "Hello, World!" in reverse order
                      @@@@@@@@@@@@@  Pop and print the last element of the stack 13 times
\$\endgroup\$
2
  • \$\begingroup\$ 1. outdated, 2. doesn't even print the right Hello, World! \$\endgroup\$
    – ASCII-only
    Aug 23, 2017 at 6:27
  • \$\begingroup\$ @ASCII-only fixed \$\endgroup\$
    – Mayube
    Aug 23, 2017 at 8:20
2
\$\begingroup\$

Emoji, 23 24 bytes

💬Hello, World!💬➡ 

Should be pretty clear. Just pushes Hello, World! and than outputs.

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

Apps Script + Google Sheets, 39 bytes

Script

function Q(){return"Hello, World!"}

Sheet

=q()

Original, 40 bytes

Script

function Q(){return "Hello, World!"}

Sheet

=q()
\$\endgroup\$
1
  • 2
    \$\begingroup\$ Can't you do return"Hello, World!"? \$\endgroup\$ Jun 29, 2016 at 21:41
2
\$\begingroup\$

AsciiDots, 18 bytes

.-$"Hello, World!"

Try it online!

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

DOBELA, 214 bytes

,,.,,,,.,..,,.,,,..,..,,,...,,.,,..,....,.,.,...,,.,,,,,,,.,..,,,..,....,..,..,,,..,..,,,..,,.,.,.,,.,,,$^
.                                                                                                         #

With comments:

!        d        l        r        o        W                 ,        o        l        l        e        H
,,.,,,,. ,..,,.,, ,..,..,, ,...,,., ,..,.... ,.,.,... ,,.,,,,, ,,.,..,, ,..,.... ,..,..,, ,..,..,, ,..,,.,. ,.,,.,,,$^
.                                                                                                                     #

H = ascii 0x48 = 01001000 = ,.,,.,,,

Put bits in FIFO then print them by hitting ^ from below.

Try it online

\$\endgroup\$
1
  • \$\begingroup\$ 123 \$\endgroup\$
    – ASCII-only
    Apr 12, 2018 at 4:20
2
\$\begingroup\$

Triangularity, 71 49 bytes

.... ....
..."!"...
.."ld"+..
." Wor"+.
"Hello,"+

Try it online!

Saved 22 bytes thanks to an ingenious method by Mr. Xcoder!

Old version

...........
...."H"....
..."ell"...
.."o, Wo"..
."rld!"W"".
.....J.....

Try it online!

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

rk, 22 + 2 (-e) = 24 bytes

print: "Hello, World!"

Requires the -e flag (remove necessity for rk:start). Try it online!

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

Stax, 8 bytes

èï┬▀↨╩4G

Run and debug online!

Explanation

èï┬▀↨╩4G is the packed form of the ASCII Stax code `jaH1"jS3!, which is in turn a compressed string literal of Hello, World! with the ending backtick omitted.

\$\endgroup\$
1
15 16
17
18 19
33

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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