502
\$\begingroup\$

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

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

The Rules

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

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

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

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

For inspiration, check the Hello World Collection.

The Catalogue

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

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

## Language Name, N bytes

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

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

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

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

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

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

/* Configuration */

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

/* App */

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

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

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

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

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

getAnswers();

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

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

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

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

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

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

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

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

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

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

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

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

table thead {
  font-weight: bold;
}

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

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

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

\$\endgroup\$
21
  • 3
    \$\begingroup\$ @isaacg No it doesn't. I think there would be some interesting languages where it's not obvious whether primality testing is possible. \$\endgroup\$ Aug 28, 2015 at 13:56
  • 6
    \$\begingroup\$ If the same program, such as "Hello, World!", is the shortest in many different and unrelated languages, should it be posted separately? \$\endgroup\$ Aug 28, 2015 at 15:33
  • 2
    \$\begingroup\$ @mbomb007 Well it's hidden by default because the three code blocks take up a lot of space. I could minify them so that they are a single line each, but I'd rather keep the code maintainable in case bugs come up. \$\endgroup\$ Aug 28, 2015 at 19:34
  • 8
    \$\begingroup\$ @ETHproductions "Unlike our usual rules, feel free to use a language (or language version) even if it's newer than this challenge." Publishing the language and an implementation before posting it would definitely be helpful though. \$\endgroup\$ Aug 29, 2015 at 23:01
  • 2
    \$\begingroup\$ @MartinEnder ... Almost. If two BF solutions have the same size, the one with smaller lexicographical order will take smaller number of bytes in Unary. Of course the smallest Unary solution translated to BF is guaranteed to be smallest. \$\endgroup\$
    – DELETE_ME
    May 20, 2018 at 10:20

931 Answers 931

1
8 9
10
11 12
32
4
\$\begingroup\$

Intcode, 201 bytes

72,4,0,-1,1101,1,100,3,4,3,1101,100,8,3,4,3,4,3,1101,100,11,3,4,3,1101,40,4,3,4,3,1101,30,2,3,4,3,1101,80,7,3,4,3,1101,100,11,3,4,3,1101,100,14,3,4,3,1101,100,8,3,4,3,1101,98,2,3,4,3,1101,30,3,3,4,3,99

And this kids is why we don't golf using languages made up for programming competitions.

\$\endgroup\$
4
  • \$\begingroup\$ mmm undefined behavior \$\endgroup\$ Dec 5, 2019 at 6:31
  • \$\begingroup\$ Invalid opcodes are just NOPs in my interpreter \$\endgroup\$
    – lyxal
    Dec 5, 2019 at 6:33
  • \$\begingroup\$ @UnrelatedString I mean, they haven't said what to do with undefined ops \$\endgroup\$
    – lyxal
    Dec 5, 2019 at 6:34
  • \$\begingroup\$ Outgolfed \$\endgroup\$ Dec 27, 2019 at 2:19
4
\$\begingroup\$

Plain English 901 308 bytes:

To run:
Start up.
Put "Hello, World!" in a b buffer.
Call "kernel32.dll" "GetStdHandle" with -11 returning a h number.
Call "kernel32.dll" "WriteFile" with the h
and the b's first and the b's length
and a r number's whereabouts and 0 returning the r.
Call "kernel32.dll" "CloseHandle" with the h.
Shut down.

ungolfed, with comments and error traps:

To run:
  Start up.
  Put "Hello, World!" in a buffer.
  Write the buffer to stdout.
  Shut down.

To write a buffer to stdout:
  Clear the i/o error.
  Get stdout returning a standard handle.
  If the i/o error is not blank, exit.
  Call "kernel32.dll" "WriteFile" with the standard handle
    and the buffer's first and the buffer's length
    and a number's whereabouts and 0 returning the number.
  Call "kernel32.dll" "CloseHandle" with the standard handle.
  If the number is not 0, exit.
  Put "Error writing to the standard error stream." into the i/o error.

To get stdout returning a standard handle:
  \ std_input_handle = -10; std_output_handle = -11
  Call "kernel32.dll" "GetStdHandle"
    with -11 [std_output_handle]
    returning the standard handle.
  If the standard handle is -1 [invalid_handle_value],
    put "Error opening the standard output stream." into the i/o error; exit.

The Plain English IDE is available at github.com/Folds/english. The IDE runs on Windows. It compiles to 32-bit x86 code.

Write a buffer to stdout and Get stdout returning a standard handle seem like good candidates for adding to Plain English's library. Similar routines already exist for stderr.

\$\endgroup\$
5
  • \$\begingroup\$ Seems like a very interesting language, but very verbose. Wow! \$\endgroup\$
    – Neil A.
    Jun 28, 2017 at 6:35
  • \$\begingroup\$ Is there a character I am missing? It shows up as 307/899 bytes for me, respectively \$\endgroup\$
    – Neil A.
    Jun 28, 2017 at 6:37
  • \$\begingroup\$ @NeilA. - Your counts are probably correct. I estimated the byte counts by adding up the (1-based) indexes of the character positions after the last character on each line. It is likely that this process resulted in an extra character being counted after the last line. This process also assumes that the lines can be separated using one byte (such as a space or line feed) instead of the actual two-byte CRLF that is used when the editor saves the file. But since Plain English is designed to successfully compile the file if the CRLFs were replaced by spaces, the latter issue is not a problem. \$\endgroup\$
    – Jasper
    Jun 28, 2017 at 15:45
  • \$\begingroup\$ @NeilA. -- My first stab at the problem was much shorter (about 76 bytes), but it launched a complete CGI environment and output to that environment's stdout. This version outputs in the stdout that the user starts in. If I make Plain English treat stdout as nicely as it treats stderr, this version can be shortened to about 88 bytes. \$\endgroup\$
    – Jasper
    Jun 28, 2017 at 15:55
  • \$\begingroup\$ @programmer5000 -- According to the rules of this challenge, "The program must not write anything to STDERR." \$\endgroup\$
    – Jasper
    Jul 19, 2017 at 15:28
4
\$\begingroup\$

naz, 64 bytes

9a8m1o3d4m5a1o7a2o3a1o3d7a1o9s3s1o3m9s1o9a9a6a1o3a1o6s1o8s1o3d1o

naz is my new language where every command is given by a number and a letter. Programs operate on a single register whose value can be between -127 and 127, inclusive.

This program uses the instructions for add, subtract, multiply, and divide to set the register to the ASCII value of each character in the string Hello, World!, then outputs that character with the o instruction. In the case of the Ls in Hello, once the register is set to the correct value, 2o is used to output twice instead of just once.

\$\endgroup\$
1
  • 3
    \$\begingroup\$ Welcome to the site :) \$\endgroup\$
    – FlipTack
    Jan 1, 2020 at 11:57
4
\$\begingroup\$

International Phonetic Esoteric Language, 16 bytes

"Hello, World!"o
"Hello, World!"  (push "Hello, World!")
               o (pop and print)
\$\endgroup\$
4
\$\begingroup\$

Arn, 6 bytes

'Mh└a└

Explanation

Unpacked:

'yt, bs!

A compressed string where every word is capitalized. Output is implicit

\$\endgroup\$
4
\$\begingroup\$

CSS, 62 bytes:

*{display:none}html{display:flex}:after{content:'Hello World!'

This is the first pure CSS on here, I think.

\$\endgroup\$
4
\$\begingroup\$

Sardonyx, 44 bytes

require"stdio"
Stdio:write("Hello, world!")

Sardonyx is a small language created for the repl.it language jam. See the link above for documentation and more!

\$\endgroup\$
4
\$\begingroup\$

MAWP, 86 62 bytes

89W!;74WM1M!;7M!!;;3M;66W8M;84W;99W6M!;64WM!;3M!;6A!;8A;66W3A;

Try it!

\$\endgroup\$
1
  • \$\begingroup\$ 64 bytes \$\endgroup\$
    – lyxal
    Aug 14, 2020 at 21:32
4
\$\begingroup\$

Kotlin, 33 bytes

fun main()=print("Hello, World!")

This is probably the shortest you can go.

\$\endgroup\$
3
4
\$\begingroup\$

Wierd (Chris's), 125 bytes

-exxxd                         !dlroW ,olleH
 x  xx
 x xxxxc
x
x  x bx  x
x xx  xx  x
xx x   xxxxx
 xx  ax
x    x
x  xxxx
 xx

Try it online

This answer is based on the excellent John's Wierd answer by Dennis.

There are 3 dialects of Wierd: John's (John Colagioia), Milo's (Milo van Handel), and Chris's (Chris Pressey). Chris Pressey presents his JavaScript interpreter as an alternative implementation of John's Wierd, but in fact it is a completely separate dialect no less different from John's Wierd than Milo's Wierd.

Main difference from John's Wierd is the swapped order of x,y arguments for PUTGET command, so letter fetching code around b was altered a bit.

Another difference is the IF command. Chris's Wierd IF behaves as in spec at all times: fall through if TOS is zero (or stack is empty), bounce back otherwise. So before IF at a we need to place 0 on stack with SUB (45° right turn). Also, exiting is different – IP bounces off e when (1,1) is space and program ends at c.

This program relies on the weird behavior of PUTGET command when the stack is empty or has one or two nonzero items. I would expect that PUTGET be a NOP when there are not enough arguments on the stack, but Chris's interpreter puts 32 on the stack in this case. This happens at d and (1,1). This is important for proper exiting.


Wierd commands:

Wierd commands

\$\endgroup\$
4
\$\begingroup\$

GotoOutput, 33 bytes

 Goto Hello,\_World!
Hello,\_World!

A less trivial solution which demonstrates the language's intended control flow would be:

 Assign g o
 Goto H
H Goto e
e Goto l
l If l
 GotoFrom g
 \_ l
 Goto l
o If o
 Goto r
 \_ o
 Goto ,
, Goto \_
\_ Goto W
W Assign g d
 Goto o
r Goto l
d Goto !
!

What is GotoOutput?

GotoOutput is a language I just made. Well, I'm actually a bot, so my owner made this language.

Goto (what I'll call it for short) has one way to output (aside from Print and PrintString for debugging, which shouldn't be valid in plain GotoOutput answers). Gotoing prints the destination. If that sounds painful, it is.

For example:

a Goto b
b Goto c
c

This program would print bc. You'll notice every line has a label, which is prefixed and separated by a space. Labels can contain backslash escapes, such as \_ for a space, or \n for a newline (this is important because there's no other way to output).

Goto uses title case operators, as one of its primary inspirations was TI-BASIC. Its only data type is the string, and it has operators like Concat, ConcatString, Tail, Reverse, Match, and OutsideMatch to work with these. It also has \_, \n, and some other escape codes as additional ways to append these characters.

Goto also has variables, which can be accessed with Assign or Copy. They can be used for control flow in If, IfNot, or GotoFrom. Input is taken with Input.

This is just a general overview of the language, but feel free to play around with it or ask me questions if you want to know more about it. This is the official interpreter:

var interpret = (instructions, input, max = Infinity) => {
    var rows = instructions.split("\n").filter(r => r.trim());
    
    var pointers = new Map();
    var variables = new Map();
    
    var back = [];
    var out = [];
    
    var match = (string, match) => {
        var out = "";

        for (var s = 0; s < string.length; s++) {
            if (string.slice(s).startsWith(match)) {
                out += match;

                s += Math.max(match.length - 1, 0);
            }
        }

        return out;
    };

    var outside_match = (string, match) => {
        var out = "";

        for (var s = 0; s < string.length; s++) {
            if (string.slice(s).startsWith(match)) {
                s += Math.max(match.length - 1, 0);

                continue;
            }

            out += string[s];
        }

        return out;
    };
    
    var parse = (string) => {
        var out = "";
        
        var b = 0;
        
        for (var s = 0; s < string.length; s++) {
            if (b) {
                out += ({
                    "_": " ",
                    "t": "\t",
                    "n": "\n",
                    "r": "\r",
                    "f": "\f",
                    "b": "\b"
                })[string[s]] || string[s];
                
                b = 0;
                
                continue;
            }
            
            if (string[s] == "\\") {
                b = 1;
                
                continue;
            }
            
            out += string[s];
        }
        
        return out;
    };
    
    var r;
    
    for (r = 0; r < rows.length; r++)
        pointers.set(rows[r].split(" ")[0], r);
    
    var row, old;
    
    for (r = 0; r < rows.length; r++) {
        row = rows[r].split(" ");
        
        old = r;
        
        if (row[1] == "Goto" && pointers.has(row[2] || ""))
            out.unshift(row[2] || ""), r = pointers.get(row[2] || "") - 1, back.unshift(r + 1);
        if (row[1] == "GotoFrom" && pointers.has(variables.has(row[2] || "") ? variables.get(row[2] || "") : ""))
            out.unshift(variables.has(row[2] || "") ? variables.get(row[2] || "") : ""), r = pointers.get(variables.has(row[2] || "") ? variables.get(row[2] || "") : "") - 1, back.unshift(r + 1);
        if (row[1] == "GoBack")
            r = (back.length < 2 ? 0 : back[1]) - 1, back.shift();
        if (row[1] == "If" && (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") == "")
            r++;
        if (row[1] == "IfNot" && (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") != "")
            r++;
        if (row[1] == "Match")
            variables.set(row[2] || "", match(variables.has(row[2] || "") ? variables.get(row[2] || "") : "", row[3] || ""));
        if (row[1] == "OutsideMatch")
            variables.set(row[2] || "", outside_match(variables.has(row[2] || "") ? variables.get(row[2] || "") : "", row[3] || ""));
        if (row[1] == "Skip")
            r++;
        if (row[1] == "Assign")
            variables.set(row[2] || "", row[3] || "");
        if (row[1] == "Copy")
            variables.set(row[2] || "", variables.has(row[3] || "") ? variables.get(row[3] || "") : "");
        if (row[1] == "ConcatString")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + (row[3] || ""));
        if (row[1] == "Tail")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "").slice(1));
        if (row[1] == "Reverse")
            variables.set(row[2] || "", [...(variables.has(row[2] || "") ? variables.get(row[2] || "") : "")].reverse().join(""));
        if (row[1] == "Concat")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + (variables.has(row[3] || "") ? variables.get(row[3] || "") : ""));
        if (row[1] == "\\_")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + " ");
        if (row[1] == "\\t")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + "\t");
        if (row[1] == "\\n")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + "\n");
        if (row[1] == "\\r")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + "\r");
        if (row[1] == "\\f")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + "\f");
        if (row[1] == "\\b")
            variables.set(row[2] || "", (variables.has(row[2] || "") ? variables.get(row[2] || "") : "") + "\b");
        if (row[1] == "Input")
            variables.set(row[2] || "", input || "");
        
        if (row[1] == "PrintString")
            out.unshift(row[2] || "");
        if (row[1] == "Print")
            out.unshift(variables.has(row[2] || "") ? variables.get(row[2] || "") : "");
        
        pointers.set(row[0], old);
        
        if (!max--)
            throw new RangeError("Hit maximum instruction count during run");
    }
    
    return out.map(parse).reverse().join("");
};

(() => {
    var main = document.getElementById("main");

    var input_0 = document.getElementById("input_0");
    var input_1 = document.getElementById("input_1");
    var input_2 = document.getElementById("input_2");

    input_0.oninput = () => {
        main.removeAttribute("data-thrown");

        try {
            var output = interpret(input_0.value, input_1.value, 200);

            input_2.value = output;
            input_2.rows = (output.match(/\r\n|\n|\r/g) || []).length + 1;
        } catch (info) {
            main.setAttribute("data-thrown", "");

            throw info;
        }
    };

    input_1.oninput = () => {
        input_0.oninput();

        input_1.rows = (input_1.value.match(/\r\n|\n|\r/g) || []).length + 1;
    }
})();
textarea {
    border: 1px solid #a0a0a0;
    display: block;
    margin-bottom: 8px;
    resize: none;
    padding: 6px;
    font-size: 10px;
    line-height: 1.25;
}

textarea:focus {
    border: 1px solid #a0d0f0;
    outline: 1px solid #a0d0f0;
}

#main[data-thrown] textarea:focus {
    border: 1px solid #f09e9e;
    outline: 1px solid #f09e9e;
}
<!DOCTYPE html>
<html lang="en">
    <head>
        <title>Goto Output</title>
        
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta charset="utf-8">
    </head>
    <body>
        <section id="main">
            <textarea id="input_0" rows="10" cols="80"></textarea>

            <textarea id="input_1" rows="1" cols="80"></textarea>
            <textarea id="input_2" rows="1" cols="80" readonly></textarea>
        </section>
    </body>
</html>

\$\endgroup\$
4
\$\begingroup\$

PICO-8, 32 bytes

?"h\69\76\76\79, w\79\82\76\68!"

PICO-8 reads code in lowercase, but prints in uppercase. Lowercase letters do exist in P8SCII, but they need to be accessed through escape codes, as demonstrated.

Alternate 32 byte solution, making use of the \* escape code to print the first two l characters:

?"h\69\*2\76\79, w\79\82\76\68!"
\$\endgroup\$
4
\$\begingroup\$

KonamiCode, 12 bytes

^^vv<><>BALS

If this seems cheaty to you, here's another one that actually does the work (168 bytes):

v(^^^^^^^>^^)<<v(^>>^)<<v(^>>^^^^^^^^)<<v(^>>^^^^^^^^)<<v(^>^>^)<<v(^^^^>^^^^)<<v(^^^>^^)<<v(^>^>^^^^^^^^^)<<v(^>^>^)<<v(^>^>^^^^)<<v(^>>^^^^^^^^)<<v(^>>)<<v(^^^>^^^)<<

And here's an annotated version: https://esolangs.org/wiki/KonamiCode/Hello_World

\$\endgroup\$
1
  • 2
    \$\begingroup\$ Welcome to Code Golf, and nice first answer! This looks like a pretty neat language. I might have to check it out! \$\endgroup\$ Nov 11, 2021 at 18:43
4
\$\begingroup\$

Sysfk (darwin64 syscalls), 1192 bytes

>>>>>>>>,[-<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>]>[-<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>]>[-<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>]>[-<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>]>[-<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>]>[-<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>]>[-<<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>>]>[-<<<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>>>]<<<<<<<<<<<<<<<|++++>>>++>>>>>>>>>>>>>+>>>>>>>>>>>>>>>>+>>>>>>>>^>>>>>>>>>+++++++++[<++++++++>-].<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++[<++++>-]<+.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++++++.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^.|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<------>-]<-.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>++++[<--->-].<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<+++++>-].<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>++++++[<++++>-].<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>------.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>--------.<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<------>-]<-.

Don't try it online because it's not there (yet?)

This can definitely be trimmed down, but I'm not an experienced enough brainfuck programmer to do that.

Sysfk is a brainfuck extension which replaces the input and output instructions with instructions to perform syscalls. This program is written for macOS systemcalls (because that's the platform I program on), but I'll make a linux version as soon as I can.

This program executes the write (0x2000004) syscall once for each character in the string "Hello, World!".

>>>>>>>>,                                                            Load the pointer to the target memory buffer
 [-<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>]                      Copy the first byte of the pointer to rsi
>[-<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>]                   Copy the second byte of the pointer to rsi
>[-<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>]                Copy the third byte of the pointer to rsi
>[-<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>]             Copy the fourth byte of the pointer to rsi
>[-<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>]          Copy the fifth byte of the pointer to rsi
>[-<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>]       Copy the sixth byte of the pointer to rsi
>[-<<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>>]    Copy the seventh byte of the pointer to rsi
>[-<<<<<<<<<<<<<<<|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+^>>>>>>>>>>>>>>>] Copy the eighth byte of the pointer to rsi
<<<<<<<<<<<<<<<|++++>>>++>>>>>>>>>>>>>+>>>>>>>>>>>>>>>>+>>>>>>>>^    Setup the remaining syscall parameters
>>>>>>>>>+++++++++[<++++++++>-].                                     Print 'H'
<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^                                    Reset syscall parameters
>>>>>>>>>+++++++[<++++>-]<+.                                         Print 'e'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++++++.                     (Reset and) Print 'l'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^.                                    (Reset and) Print 'l'
|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++.                                 (Reset and) Print 'o'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<------>-]<-.   (Reset and) Print a comma
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>++++[<--->-].               (Reset and) print ' '
<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<+++++>-].     (Reset and) print 'W'
<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>++++++[<++++>-].           (Reset and) print 'o'
<<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>+++.                        (Reset and) print 'r'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>------.                      (Reset and) print 'l'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>--------.                    (Reset and) print 'd'
<<<<<<<<|+++>>>++>>>>>>>>>>>>>+^>>>>>>>>>+++++++++++[<------>-]<-.   (Reset and) print '!'
\$\endgroup\$
4
\$\begingroup\$

NLRNIS, 15 bytes

>#Hello, World!

My first TC (?) Programming language.

the interpreter is here

Explanation:

>#Hello, World!"H
>
 #
  Hello, World!   Define # = "Hello, World!"

(implicit output the variable # only)
\$\endgroup\$
4
\$\begingroup\$

CASL II, 55 43 bytes.

CASL II is an assembly language for COMET II, the fictional architecture. It is designed for Japan Information-Technology Engineers Examination.

Here is the page that you can obtain official specification, as Information Technology Terms and Specifications of Programming Languages Used in Examination Questions.

I've found a way to specify a literal instead of an address:

A START
 OUT ='Hello, World!',=13
 RET
 END

Previous version

55 bytes

Z START
 OUT A,B
 RET
A DC 'Hello, World!'
B DC 13
 END

Links (they are in Japanese)

\$\endgroup\$
4
\$\begingroup\$

tinylisp, 40 bytes

(load library
(join(q(Hello, World!))spc

Try it online!

tinylisp, 56 bytes

(string(q(72 101 108 108 111 44 32 87 111 114 108 100 33

Try it online!

Considering tinylisp's lack of strings, this is very likely the best hello world without libraries.

\$\endgroup\$
4
\$\begingroup\$

dotcomma, 494 bytes

[[[[[[[[[[[[[[[[[[[.][.].,][,.].,][,.].,][,.].,][,.].,][.].,][.][.][.][.][.][.][.][.][.][.][.].,][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.].,][.][.][.][.][.][.][.][.][.][.][.][.][.][.][.].,][.][.][.][.][.][.][.][.][.][.][.][.][.].,][.].,][.][.][.][.][.][.][.].,],],][.][.][.].,],][.][.][.].,][,][[,.][[[,][,][,][[,.][[[,][[,.][[[,][,][,][,][[,.][[[,][,][,][,][,][,][,][[,.][[[,][,][,][,][[,.][[[,][,][,][,][[,.][[[,]]].,]]].,]]].,]]].,]]].,]]].,]]].,]]

Dotcomma is a language I made, designed to do as much as possible with the fewest instructions. Interestingly, it uses a queue rather than a stack. The final state of the queue is used as output.

I've put a high level explanation below, but even I don't fully understand how I got this to work :p

The easy part was generating all the necessary letters, ordered by code point ( !,HWdellloor):

First, it generates the code point for a space (32): [[[[[[.][.].,][,.].,][,.].,][,.].,][,.].,]. Then, it wraps that in a number of [<n> [.]* .,] blocks, which increment the value and adds it to the queue, with the number of [.]s being the amount it increments

Then it needs to sort the queue so that it displays in the correct order (Hello, World!):

Without an accumulator or second queue, this is difficult. The workaround is to use the execution order to read a value, perform an operation that modifies the queue, then add the result (0) to the previously read value. This re-adds the value into the queue, at the end. If the operation performed is a shift, the stored value can be placed anywhere into the queue. Working backwards from ! to , it will shift the queue with a number of [,]s. The temporary addition-based storage is implemented as [[,.] [[ <previous letter> ]] .,]. Importantly, this is nested in a way that each time it does this is returns 0 so it won't mess up the rest. Luckily, after the , is shifted, Hello is already in order.

\$\endgroup\$
4
\$\begingroup\$

Tarfish, 160 bytes

x++++++++++++++++++++++++++++++++:+:+++++++++++:++++++++++++++++++++++++++++:.+++++++++++++++:++++++++++++++:.+++++++:::..+++:.{{{.{.{{.}}.:++++++.:.--------..;

Try It Online!

Tarfish is an esolang of mine that is a more tarpit-style version of ><>. This answer doesn't really use that much of its 2D features, but it works.

Note: a single + or - means multiple, I'll specify how many. After each line is a visualisation of the stack as characters.

x                                             # Push a 0 - [0]
 +                                            # Increment to 32 - ' '
  :+                                          # Duplicate and increment - ' !'
    :+                                        # Duplicate and increment to 44 - ' !,'
      :+                                      # Duplicate and increment to 71 - ' !,H'
        :.                                    # Duplicate and output - ' !,H'
          +:                                  # Increment to 87 and duplicate -  ' !,WW'
            +:.                               # Increment to 101, duplicate and output - ' !,We' 
               +:::..                         # Increment to 108, quadruple and output twice - ' !,Wll' 
                     +:.                      # Increment to 111, duplicate and output - ' !,Wlo'
                        {{{.                  # Cycle right three times to the comma and output - 'Wlo !'
                            {.                # Cycle right once to the space and output - '!Wlo'
                              {{.             # Cycle right twice to the W and output - 'lo!'
                                 }}.          # Cycle left twice to the o and output - '!l'
                                    :+.       # Duplicate, increment to 114 and output - '!l'
                                       :.-    # Duplicate, output, and decrement to 100 - '!d'
                                          ..; # Output twice and halt
\$\endgroup\$
4
\$\begingroup\$

C# 9+, 38 bytes

System.Console.Write("Hello, World!");

As of C# 9, the compiler directly supports top-level statements in a single file.
This means that the infamous boilerplate of class Program { static void Main(string[] args) {...} } will be inferred at compile-time, and the top-level statements in the file will be directly inserted into the Main method.

As a result of this, C# is now able to achieve a complete Hello World program in just 38 bytes!

\$\endgroup\$
4
\$\begingroup\$

flax C, 14 bytes

"Hello, World!

The first answer to use flax.

Explanation

The program is a niladic chain, which means it does not take any arguments.

Even though "Hello, World! looks like a string, in flax it is represented as numbers in ASCII. Hence we need the C flag to print as characters instead of numbers.

\$\endgroup\$
2
  • 5
    \$\begingroup\$ @Downvoter explain yourself please. \$\endgroup\$
    – PyGamer0
    Feb 19 at 11:07
  • 1
    \$\begingroup\$ Downvote was likely because it's a trivial answer, but like...HW basically exists to catalog Hello, World! programs, most of which are trivial, so that's a bit of a sussy baka move whoever did it. \$\endgroup\$ May 30 at 3:42
4
\$\begingroup\$

Scratch, 33 bytes

when gf clicked
say[Hello, World!

enter image description here

\$\endgroup\$
4
\$\begingroup\$

Flobnar, 34 bytes

Hello, World!�
:> v:
g|\@>!,
00> +

Try it online!

(Previous record: 41)

The last character at the end of the first line is the null character \0.

@    Start the program

  :  :
\ >!,g    Initially n (top of stack) = 0.
> +  0    Print the char at (n, 0), push n+1, and evaluate the left of \:

:> v
g|\@    If the char at (n, 0) is zero, evaluate to zero;
00      otherwise go to the start of the program with updated n
\$\endgroup\$
3
\$\begingroup\$

Wheat, 32 Bytes

Wheat is an esolang that is based on outputting and inputting. Only what has been output on a previous cycle can be input on the current one. The buffers last only one cycle; if the data of previous cycle is not read on current cycle, on the next cycle it can not be accessed, it will all be erased, replaced by the output of the current cycle (if any, otherwise the empty string is used).

output "Hello, World!"
terminate
\$\endgroup\$
1
  • 1
    \$\begingroup\$ The description of Wheat that you gave is taken directly from the Wheat esolang page. Care to cite? \$\endgroup\$ Jan 21, 2018 at 6:41
3
\$\begingroup\$

Gibberish, 17 Bytes

Surprisingly, the shortest answer I could make is not gibberish at all.

[Hello, World!]eo
\$\endgroup\$
3
\$\begingroup\$

golflua, 16 bytes

w"Hello, World!"
\$\endgroup\$
3
\$\begingroup\$

CJam, 15 bytes

"Hello, World!"

Try it online

\$\endgroup\$
3
\$\begingroup\$

XSM, 28 bytes

<print>Hello, World!</print>
\$\endgroup\$
3
  • \$\begingroup\$ This is an actual XML programming language? Wow. That's... different! \$\endgroup\$
    – galexite
    Aug 28, 2015 at 17:09
  • 1
    \$\begingroup\$ Damn it, I was hoping I could write my own... Now someone's already gone and made it :P \$\endgroup\$
    – Beta Decay
    Aug 29, 2015 at 7:12
  • \$\begingroup\$ @BetaDecay There is also xplusplus.sourceforge.net and o-xml.org \$\endgroup\$ Aug 30, 2015 at 23:15
3
\$\begingroup\$

GolfScript, 15 bytes

"Hello, World!"
\$\endgroup\$
3
\$\begingroup\$

Underload, 16 bytes

(Hello, World!)S

Underload is the Brainfuck of stack-based languages. (x) pushes the string x to the stack, and S prints the value on top of the stack.

\$\endgroup\$
1
8 9
10
11 12
32

Your Answer

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

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