441
\$\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

788 Answers 788

1
8 9
10
11 12
27
3
\$\begingroup\$

PlatyPar, 14 bytes

"Hello, World!

In PlatyPar (my language that is still in development), parens, quotes, brackets, etc. are automatically closed at the end of the line. Additionally, the last item on the stack (in this case, "Hello, World!") is implicitly printed.

Try it here!

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

Acc!!, 122 bytes

Due to limitations of the scoreboard snippet, the title of this post is incorrect. The correct name of this language is Acc!! with italics.

108
Write 72
Write 101
Write _
Write _
Write 111
Write 44
Write 32
Write 87
Write 111
Write 114
Write _
Write 100
Write 33

The first line stores 108 (char code for l) in the accumulator. The rest writes Hello, World! one character at a time, with _ referencing the accumulator value. Using the accumulator beats the straightforward version by 2 bytes. :^)

Works the same in Acc!.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ @quartata Thanks for the edit, but italics in the language name breaks the scoreboard. \$\endgroup\$ – DLosc Jan 20 '16 at 22:56
  • \$\begingroup\$ Ah. Sorry, didn't realize :P \$\endgroup\$ – a spaghetto Jan 20 '16 at 23:45
  • \$\begingroup\$ Maybe the scoreboard snippet should be updated. \$\endgroup\$ – mbomb007 Jan 22 '16 at 17:58
3
\$\begingroup\$

VHDL, 98 bytes

entity m is
end;architecture a of m is
begin
process
begin
report"Hello, World";end process;end a;

At least it's not Java...

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ class a{public static void main(String[]a){System.out.print("Hello, World!");}} Nope, you've been Java'd. Also this appears to print "Hello World", not "Hello, World!" \$\endgroup\$ – CalculatorFeline Mar 25 '16 at 23:56
3
\$\begingroup\$

Verilog, 60 bytes

module m;initial
begin
$write("Hello, World!");end
endmodule

Try it online here.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ The initial block doesn't need begin & end. \$\endgroup\$ – ahmedus Jun 22 at 22:46
3
\$\begingroup\$

Y 16 bytes

No, not http://foldoc.org/Y or https://github.com/ConorOBrien-Foxx/Y although we probably need an entry for both of them as well...

Y is a stack-oriented FORTH-type programming language by Thomas Fischbacher derived from Wouter van Oortmerssen's "FALSE". Like FALSE, Y is cryptic to the extreme. According to the readme it is much more powerful because "virtually all of the example programs in 'Kernighan & Ritchie - Programming in C' can be done in Y in a fraction of time and code."

"Hello, World!"`
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Kotlin, 50 48 bytes

fun main(a:Array<String>)=print("Hello, World!")
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Fuzzy Octo Guacamole, 15 bytes

"Hello, World!"

This is a new language I created with inspiration from @Conor's NTFJ, @MatinBüttner's Brian and Chuck, and a couple others.

It has 2 stacks.

This is fairly simple and only uses one stack though.

The "..." denotes a string literal that is pushed to the stack.

Then implicit output.

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

Pyramid, 587 294 bytes

(72)[
no
+<
]
=
a
<
=
np
<
=
(29)[
no
+<
]
=
a
<
=
np
+<
=
a
++++++<
=
np
<
=
a
<
=
np
+<
=
a
++<
=
np
<
=
(67)[
no
-<
]
=
a
<
=
np
-<
=
a
-----------<
=
np
<
=
(55)[
no
+<
]
=
a
<
=
np
<
=
(24)[
no
+<
]
=
a
<
=
np
<
=
a
+++<
=
np
<
=
a
------<
=
np
<
=
a
--------<
=
np
<
=
(67)[
no
-<
]
=
a
<

Yikes... this is a monstrosity. This is now less of a monstrosity, but still crazy big for "Hello, World!".

The new byte count was because for-loops were implemented in Pyramid (YES!)

Pyramid is a stack-based language, which was built on Stackylogic. You should probably go and click on the link before you go to the Github page, because you'll understand the what the commands mean on the GH page better.

There's 250 104 lines of code here, if you're interested.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ link 404 why :(? \$\endgroup\$ – Destructible Lemon Sep 23 '16 at 3:09
  • \$\begingroup\$ @DestructibleWatermelon Oh yeah, that's because I stopped working on Pyramid. \$\endgroup\$ – clismique Sep 23 '16 at 6:40
3
\$\begingroup\$

Processing, 23 bytes

print("Hello, world!");

It also opens a window for drawing, but this message does go to stdout in the IDE.

I don't understand why more people don't use Processing over Java for code golf. With most of the boilerplate removed, you can almost always outdo it with the same syntax.

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

Codelike, 127 bytes

on++++++++n+++n+++**pn++++n+++++++*+ap+++++++pp+++pn++++n++++++++*pfn++n++++*ap________p+++p______p________pn++++n++++++++*+pfe

Try it!

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

*><>, 21 bytes

"!dlrow ,olleH"Ool?u;

Try it out on the online interpreter here.

*><> (pronounced "Starfish") is an esolang based on ><>, developed by redstarcoder. Its aim is to add some useful features which are missing from base ><>, such as file IO, time functionality, and an interesting feature called 'dive/rise', which is used here.

If the 'dive' command, u is encountered, no instructions other than directional modifiers are executed until a 'rise' command, O, is encountered. Encountering a dive whilst already diving, or a rise when not diving, is treated as a no-op.

"!dlrow ,olleH"Ool?u;   

"!dlrow ,olleH"         Push "Hello, world!" to the stack in reverse.
               O        Rise - a no-op on first iteration
                o       Output top of stack as ASCII character
                 l?u    If length of stack is non-zero, dive
                    ;   End program execution
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ I love ><> and been interested in *><> so using the dive command for a huge benefit which I haven't seen before is great :) \$\endgroup\$ – Teal pelican Dec 19 '16 at 14:47
3
\$\begingroup\$

Pushy, 16 bytes

`Hello, World!`"

Try it online!

The first thing to note is that Pushy has no string type. The backticks open/close "stringmode": every character in between has its codepoint (as an integer) pushed to the stack. The " is the print command, which takes all the stack's values, converts them to the corresponding chars, and prints the string.

In the very first version, before stringmode was implemented, program looked like this (can probably be golfed more):

72HhH8+&&3+44 32 87 111&3+&6-H33"

It basically just appends the necessary ASCII code points, then prints.

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

DUP, 31 bytes

0$"Hello, World!"\[^^>][$;,1+]#

DUP is a descendant of FALSE, with FALSE being a subset of DUP in most aspects—with a few exceptions. One exception being the way strings are handled. See the FALSE solution in this thread for comparison. In DUP, strings cannot be ouput to STDOUT directly unless the characters are output one by one like this:

'H,'e,'l,'l,'o,',,' ,'W,'o,'r,'l,'d,'!,     (this solution would be 39 bytes long)

' pushes the Integer value of the following character on the data stack. , prints the character according to the integer value on the stack to STDOUT.

For shorter strings, this method is usually the shortest way, but in the case of Hello, World! this method is beyond the break even point of the actual string handling method of DUP.

0$"Hello, World!"\[^^>][$;,1+]#

This method successively assigns the characters between both double quotes " to addresses of a cell array, starting at a given address (in this case address 0).

In this case, the cells would carry the values

0=72 1=101 2=108 3=108 4=111 5=44 6=32 7=87 8=111 9=114 10=108 11=100 12=33 

After assigning the values to the cells, the length of the stored string gets pushed on the stack (in this case 13). The while loop [^^>][$;,1+]# at the end reads out the cell content, starting at 0, prints the according character to STDOUT, increments the counter, and repeats the procedure until the string length 13 is reached.

Try out the solution in this online DUP interpreter or clone my DUP interpreter written in Julia from my GitHub repository, the latter coming with a thorough explanation of all operators.

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

Whirl, 1350 bytes

I found this Hello, World! example was written by Kang Seonghoon in 2005. I'm including it here for completeness and because I found it helpful along with this visual demonstration of Whirl.

110011100111000001111100000001000011111000011111100000000010
000011001111100001100010000010011111000100000000000001001111
100000111110001000000000000000001000111110010000001100001111
100011000000000100111110011100111000111000001000111000001111
100000111110010000011111000110011111100001111000001111000001
110011111100001111000110011100000111000100011111000001111100
100000110000000111000001110001111100011111000111000001000001
000011000111110001000001000000011100000111001000111110001111
000001111000011111100001111110000011110000000000000000011110
000011100111000011110011111000111110001111100000100000000000
000000000000111110001110000001110000011100011100111110001000
100000000011100001111100110000000010011111000111100000111100
111100010011100000111110000011111001100111100010001111000000
000001000111110010000010011110011001110001000111110001100000
100011111000011110011100111111000111100000111100011111000000
011110000011100100001111000100011111001100011111000111100000
111001110001100111100100000000000000011111000001111100010010
000011100001111100100000100011100000111000110011110001001111
110001100000111100011111000111100000111001000011110001001111
100000111110000000011110000011110000000000000000111000001110
000011000001100000111000111000001100111110000111111001001110
000011111000001100011000001001111110000011100110011111000000
000111000001110000111100001100
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Threead, 16 bytes

"Hello, World!"o

Try it online!

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

Traffic, 191 bytes

##########################
#+#+#+#+#*#+#+#+#*#*#+#+#+#
#7#9#9#9#3#4#3#8#3#3#9#9#3
#2#9#9#9#7#4#2#7#7#8#9#9#3
#0#2#9#9#3#0#0#0#3#3#9#1#0
#$#$#$#$#$#$#$#$#$#$#$#$#$#

 C C C C C C C C C C C C C

Traffic is a 2D language modelled after cars moving around streets. Each car holds a value (acting as a variable).

This language is as bad at dealing with "strings" as Brainfuck is, so this is kinda bulky.

How it works

An ungolfed/more "proper" version of the above would look like this:

###########################
# # # # # # # # # # # # # #
#7#9#9#9#3#4#3#8#3#3#9#9#3#
#2#9#9#9#7#4#2#7#7#8#9#9#3#
#+#+#+#+#*#+#+#+#*#*#+#+#+#
# # # # # # # # # # # # # #
#0#2#9#9#3#0#0#0#3#3#9#1#0#
#$#$#$#$#$#$#$#$#$#$#$#$#$#

 C C C C C C C C C C C C C

In this program, 13 cars are defined: all the digits directly adjacent to a $ (in the #$# constructions) become cars with that initial value. So the program begins with cars that have values 0 2 9 9 3 0 0 0 3 3 9 1 0. The cars' initial directions are away from the $.

The streets are defined as the space between #s; #s comprise the walls that cars can't pass through.

All the cars move upwards. They pass over the literal, ignoring it because they haven't seen an operator to use yet. Once the reach the top, they'll each see an operator (either + or *). On the next step, they'll all turn around because they hit a dead end.

Now when walking back downwards, they will observe the literal, since they have operators to use. After fully walking over each literal (i.e. reaching the start point again), each car performs its operation using the literal and assumes the result of the operation. This results in each car containing the ASCII value of a character in Hello, World!: 72 101 108 108 111 44 32 87 111 114 108 100 33.

Then they all step on the $. The $ is a street exit, and one of a few valid characters usable for those. The $ means to output the specified value and destroy the car. The output value for each $ is C, meaning to output the ASCII character given by the car's value.

After all cars hit their respective $s, there won't be any cars left in the field. Thus, the program terminates.

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

PUPPY, 369 bytes

WOOFBARKWOOFBARKWOOFWOOFBARKWOOFBARKWOOFWOOFWOOFWOOFBARKBARKBARKBARKBARK WOOFBARKWOOFBARKWOOFWOOFBARKW OOFBARK  WOO Fwoofbarkbarkwoofwoofwoofwoofwoofwoofwoofwoofwoofbarkwoofwoofwoofbark woofbarkbark BARKWOOFWOOFBARKWOOFBARKBARKWOOFWOOFBARKBARKBARKWOOFBAR KWOOFWOOFBARKBARKBARKWOO FBA rkwoof woofwoof barkbarkbarkwoofbarkwoofbarkwoofwoofbarkwoofbarkbarkbarkwoofwoofbar k

The language that can only be read by puppies.

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

;# 1142 bytes

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

;# isn't Turing Complete and doesn't meet the site's standard for a valid language but why not?

; adds one to the accumulator

# outputs the accumulator mod 127

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ isn't Turing Complete and doesn't meet the site's standard it does, since this is kolmogorov-complexity. \$\endgroup\$ – Erik the Outgolfer May 7 '17 at 17:49
  • \$\begingroup\$ @EriktheOutgolfer yeah yeah, you know what I mean. \$\endgroup\$ – caird coinheringaahing May 15 '17 at 19:14
3
\$\begingroup\$

Ook!, 779 bytes

Ook! Ook! Ook! Ook! Ook? Ook. Ook! Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook! Ook? Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook! Ook! Ook. Ook? Ook! Ook! Ook. Ook? Ook! Ook! Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook? Ook! Ook? Ook. Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook! Ook. Ook! Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook! Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook! Ook.

Based on the shortest Brainfuck Hello World :)

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

Folders (pure), 195 folders

Some languages, like Folders, are a bit tricky to score

I'm not sure how it translates to bytes, but we can just count the number of folders: (src)

$ ls -l -R . | grep -c ^d
195
$ ls -l -R . | grep :$
./New folder:
./New folder/New folder:
./New folder/New folder/New folder:
./New folder/New folder/New folder (2):
./New folder/New folder/New folder (3):
./New folder/New folder/New folder (4):
./New folder/New folder (2):
./New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder/New folder (2):
./New folder/New folder (2)/New folder/New folder (3):
./New folder/New folder (2)/New folder/New folder (4):
./New folder/New folder (2)/New folder/New folder (5):
./New folder/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy/New folder (2)/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (10)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (11):
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (11)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (12):
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (12)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (2)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (3)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (4)/New folder (2)/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (5)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (6)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (7)/New folder (2)/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (8)/New folder (2)/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9):
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (3):
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (3)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (4):
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder/New folder (4)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2):
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2)/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2)/New folder/New folder:
./New folder/New folder (2)/New folder (3)/New folder - Copy (9)/New folder (2)/New folder (2):

Folders (concise), 2 folders + (5 + 13) bytes

./Setup
./Setup/Hello, World!
| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Welcome to PPCG! / Using inline code formatting can be quite hard to read, I edited the answer. \$\endgroup\$ – user202729 Feb 2 '18 at 10:29
  • \$\begingroup\$ Does this include the comma? I don't see one in your concise version but I don't have a folders installation to check. \$\endgroup\$ – Potato44 Feb 6 '18 at 22:21
  • \$\begingroup\$ According to the original site, (and by the number of folders) it is with the comma. I fixed my concise example. \$\endgroup\$ – Eran W Feb 7 '18 at 0:44
  • 1
    \$\begingroup\$ Easier way to count: find * -type f | wc -l (counts lines of output) \$\endgroup\$ – Peter Cordes Apr 13 '18 at 2:57
  • \$\begingroup\$ Right, It is shorter by one character... But I could use -lR \$\endgroup\$ – Eran W Apr 14 '18 at 8:21
3
\$\begingroup\$

Wumpus, 19 bytes

"!dlroW ,olleH"l&o@

Try it online!

Introducing the first 2D language on a triangular grid! (Unfortunately, you're not seeing much of that grid in this answer...)

Explanation

"!dlroW ,olleH"   Like in many other Fungeoids, this pushes the individual code
                  points of the string to the stack.
l                 Push the stack depth, 13.
&o                Print 13 characters.
@                 Terminate the program.
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Forked, 42 bytes

89*@AA*i@7+@@3+@4B*@C'!sF+!@3+@6'@8'!3B*!&

Try it online!

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

AlphaBeta, 68 bytes

kjjjggDLeaCLcbbbCLLaaaCLjjjggDLjhhDLsFihhDLCLaaaCLdaaaaCLdaaCLsFiiDL

Try it online!

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

Dodos, 167 164 160 159 bytes

	* 2
	1 0 4
	L
	L
	1 *
	4 3 1
	2 1 1
	2 2 3
	1 *
	4 *
	L
	+ 0 0 4
	3 1 1
L
	3 1 4
*
	2 4
+
	dot
i
	+ j
j
	
	dip + dab
0
	
	
	
	
	
1
	i + 0
2
	i 1
3
	i 2
4
	i 3

@Thanks to @Leo for golfing off 1 byte!

Try it online!

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

x86/x86_64 on Linux, 34 32 31 bytes

00:      e8 0d 00 00 00          call   <+0x12>
05:      48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21
                                 "Hello, World!"
12:      59                      pop    %ecx
13:      6a 01                   push   $0x1
15:      5b                      pop    %ebx
16:      6a 0d                   push   $0xd
18:      5a                      pop    %edx
19:      6a 04                   push   $0x4
1b:      58                      pop    %eax
1c:      cd 80                   int    $0x80
1e:      c3                      ret

Main differences between this one and grc's version: mine makes no assumption of prior register contents, works in both x86 and x86_64 modes and does a ret in lieu of a sys_exit() syscall.

If you want to Try it online!, compile and run the following C program.

const char main[]="\xe8\r\0\0\0Hello, World!Yj\1[j\rZj\4X\xcd\x80\xc3";

Note that Windows Services for Linux currently doesn't seem to support this type of syscall.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ The difference is that yours is a function, @grc's is code that only works from _start in a static executable (where Linux does give you zeroed registers), and runs sys_exit when it's done. (And BTW, this won't work in 64-bit PIE executables (so your sample caller fails on many recent Linux distros where gcc -pie is the default, or any other context where the code is outside the low 32 bits. int 0x80 truncates pointers to 32 bits) \$\endgroup\$ – Peter Cordes Apr 13 '18 at 4:31
  • \$\begingroup\$ If you make position-dependent code, you could use mov $msg, %ecx (5 bytes) instead of call/pop. Put msg after the ret in your function. You can also save instructions (but not code size) by using lea 3(%ebx), %eax (3 bytes) instead of push/pop, after getting a known value of ebx=1. (Still portable between ia32 and x86-64 with the same machine code, because lea 3(%rbx),%eax is safe. Tips for golfing in x86/x64 machine code). Other than position-dependent mov r32, imm32, I don't see a way to make this shorter. \$\endgroup\$ – Peter Cordes Apr 13 '18 at 4:36
  • \$\begingroup\$ Here's a 30-byte version godbolt.org/g/xAcGMg (position-dependent, and avoiding push/pop in favour of xor-zero/inc and LEA). Note that as a function, it clobbers EBX, thus violating the standard calling convention. That's fine for asm functions, though, but maybe something to mention when you're showing how to use it as a C main. The CRT code that calls main doesn't actually break if main clobbers EBX on my system, last I checked, but it could. \$\endgroup\$ – Peter Cordes Apr 13 '18 at 4:46
  • \$\begingroup\$ *window subsystem for linux \$\endgroup\$ – ASCII-only Apr 17 '18 at 11:10
3
\$\begingroup\$

Aubergine, 29 bytes

-a1=oA-a1:bA=iB\0!dlroW ,olleH

Where \0 is a null byte

Try it online!

Explanation

-a1                             Decrement a (now points to H)
   =oA                          Output *a (loop starts here)
      -a1                       Decrement a
         :bA                    If *a is not 0 (we're not at null byte), jump to b (which is 0). IP then moves by 3, so IP starts at 3 next tick
            =iB                 Else move IP to *b, which is the character code of `-`, moving us out of bounds and ending execution without error.
               \0!dlroW ,olleH
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Meq, 145 111 bytes

.==++>:+>+>[:++++++++>]:=+>====++++>===++>.===+++++++>:=+>:=++++>:++++++++>:>===+++rp>p>>p>p>p>p>p>p>p>p>p>p>p!

Thanks Steadybox for saving 34 bytes

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Welcome to PPCG! As far as I can tell, this is just the HW from the esolangs page (which seems to print Hello World) with two characters dropped. Does this actually print the correct punctuation of Hello, World!? \$\endgroup\$ – Martin Ender Mar 16 '18 at 9:41
  • \$\begingroup\$ @MartinEnder It does not, it prints Helo World. (And the original prints Hello World.) \$\endgroup\$ – Ørjan Johansen Mar 16 '18 at 9:56
  • 1
    \$\begingroup\$ .==++>:+>+>[:++++++++>]:=+>====++++>===++>.===+++++++>:=+>:=++++>:++++++++>:>===+++rp>p>>p>p>p>p>p>p>p>p>p>p>p! should work. \$\endgroup\$ – Steadybox Mar 16 '18 at 10:37
3
\$\begingroup\$

Rockstar, 21 bytes

Shout "Hello, World!"

Yeah, kinda boring... oh well.

| improve this answer | |
\$\endgroup\$
  • 5
    \$\begingroup\$ You can save 2 bytes by using Say instead of Shout. \$\endgroup\$ – RamenChef Sep 27 '18 at 13:58
3
\$\begingroup\$

Pikachu, 1562 bytes

So simple even Pikachu can do it!

pi pi pika pi pi pika pi pi pika pi pikachu
pi pika
pi pika pikachu
pi pika pika pikachu
pi pika pi pi pika pi pi pika pi pikachu
pi pikachu pi pikachu
pikachu pikachu pi pikachu
pika pi
pika pi
pi pikachu pi pikachu
pi pi pikachu
pi pika pi pikachu
pikachu pikachu pi pikachu
pika pi
pika pi
pi pikachu pi pikachu
pi pi pika pi pi pika pi pika pi pikachu
pi pika pi pikachu
pikachu pikachu pi pikachu
pika pi
pika pi
pi pikachu pi pikachu
pi pi pika pi pi pika pi pika pi pikachu
pi pika pi pikachu
pikachu pikachu pi pikachu
pika pi
pika pi
pi pikachu pi pikachu
pi pi pika pi pi pika pi pi pika pi pika pi pikachu
pi pika pi pikachu
pikachu pikachu pi pikachu
pika pi
pi pi pika pi pi pikachu
pi pikachu pi pikachu
pi pi pika pi pi pikachu
pi pika pi pikachu
pikachu pikachu pi pikachu
pika pi
pi pi pika pi pikachu
pi pikachu pi pikachu
pikachu pi pi pikachu
pi pika pi pikachu
pikachu pikachu pi pikachu
pika pi
pi pika pi pi pika pi pi pika pi pikachu
pi pikachu pi pikachu
pika pi pi pika pi pi pika pi pikachu
pi pika pi pikachu
pikachu pikachu pi pikachu
pika pi
pika pi
pi pikachu pi pikachu
pi pika
pi pika pi pi pika pi pi pika pi pi pika pi pikachu
pi pika pi pikachu
pikachu pikachu pi pikachu
pika pi
pi pika pi pi pika pi pi pika pi pi pika pi pi pika pi pikachu
pi pika pi pikachu
pikachu pikachu pi pikachu
pika pi
pi pika pi pi pika pi pi pika pi pikachu
pi pika pi pikachu
pikachu pikachu pi pikachu
pikachu pikachu pika pikachu
pika pi
pi pi pika pi pikachu
pi pika
pi pikachu pi pikachu
pika pi
pi pika pi pikachu
pikachu pikachu pi pikachu

Try it at Trove42! (Copy and paste above text)

Commented

# H
pi pi pika pi pi pika pi pi pika pi pikachu         # push 9 to `pi` stack 
pi pika                                             # copy top of `pi` stack, 9, to `pika` stack
pi pika pikachu                                     # push 1 to `pika` stack 
pi pika pika pikachu                                # add top two elements of `pika` stack
                                                    # push result, 10, to `pika` stack 
pi pika pi pi pika pi pi pika pi pikachu            # push 9 to `pi` stack 
pi pikachu pi pikachu                               # multiply top two elements of `pi` stack
                                                    # push result, 72, to `pi` stack 
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 72, 
                                                    # to ASCII, 'H', and print

# e                                                 
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pi pikachu pi pikachu                               # multiply top two elements of `pi` stack
                                                    # push result, 100, to `pi` stack
pi pi pikachu                                       # push 1 to `pi` stack
pi pika pi pikachu                                  # add top two elements of `pi` stack
                                                    # push result, 101, to `pi` stack 
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 101, 
                                                    # to ASCII, 'e', and print

# l
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pi pikachu pi pikachu                               # multiply top two elements of `pi` stack
                                                    # push result, 100, to `pi` stack
pi pi pika pi pi pika pi pika pi pikachu            # push 8 to `pi` stack
pi pika pi pikachu                                  # add top two elements of `pi` stack
                                                    # push result, 108, to `pi` stack 
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 108, 
                                                    # to ASCII, 'l', and print

# l
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pi pikachu pi pikachu                               # multiply top two elements of `pi` stack
                                                    # push result, 100, to `pi` stack
pi pi pika pi pi pika pi pika pi pikachu            # push 8 to `pi` stack
pi pika pi pikachu                                  # add top two elements of `pi` stack
                                                    # push result, 108, to `pi` stack 
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 108, 
                                                    # to ASCII, 'l', and print

# o
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pi pikachu pi pikachu                               # multiply top two elements of `pi` stack
                                                    # push result, 100, to `pi` stack
pi pi pika pi pi pika pi pi pika pi pika pi pikachu # push 11 to `pi` stack
pi pika pi pikachu                                  # add top two elements of `pi` stack
                                                    # push result, 101, to `pi` stack 
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 111, 
                                                    # to ASCII, 'o', and print

# "," (comma)
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pi pi pika pi pi pikachu                            # push 4 to `pi` stack
pi pikachu pi pikachu                               # multiply top two elements of `pi` stack
                                                    # push result, 40, to `pi` stack
pi pi pika pi pi pikachu                            # push 4 to `pi` stack
pi pika pi pikachu                                  # add top two elements of `pi` stack
                                                    # push result, 44, to `pi` stack 
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 44, 
                                                    # to ASCII, ',', and print

# " " (space)
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pi pi pika pi pikachu                               # push 3 to `pi` stack
pi pikachu pi pikachu                               # multiply top two elements of `pi` stack
                                                    # push result, 40, to `pi` stack
pikachu pi pi pikachu                               # push 2 to `pi` stack
pi pika pi pikachu                                  # add top two elements of `pi` stack
                                                    # push result, 32, to `pi` stack 
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 32, 
                                                    # to ASCII, ' ', and print
                                                    
# W
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pi pika pi pi pika pi pi pika pi pikachu            # push 8 to `pi` stack
pi pikachu pi pikachu                               # multiply top two elements of `pi` stack
                                                    # push result, 80, to `pi` stack
pika pi pi pika pi pi pika pi pikachu               # push 7 to `pi` stack
pi pika pi pikachu                                  # add top two elements of `pi` stack
                                                    # push result, 87, to `pi` stack 
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 87, 
                                                    # to ASCII, 'W', and print

# o
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pi pikachu pi pikachu                               # multiply top two elements of `pi` stack
                                                    # push result, 100, to `pi` stack
pika pi                                             # copy top of `pi` stack, 100, to `pika` stack
pi pika pi pi pika pi pi pika pi pi pika pi pikachu # push 11 to `pi` stack
pi pika pi pikachu                                  # add top two elements of `pi` stack
                                                    # push result, 111, to `pi` stack 
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 101, 
                                                    # to ASCII, 'o', and print

# r
pika pi                                             # copy top of `pika` stack, 100, to `pi` stack
pi pika pi pi pika pi pi pika pi pi pika pi pi pika pi pikachu  # push 14 to `pi` stack
pi pika pi pikachu                                  # add top two elements of `pi` stack
                                                    # push result, 114, to `pi` stack 
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 114, 
                                                    # to ASCII, 'r', and print

# l
pika pi                                             # copy top of `pika` stack, 100, to `pi` stack
pi pika pi pi pika pi pi pika pi pikachu            # push 8 to `pi` stack
pi pika pi pikachu                                  # add top two elements of `pi` stack
                                                    # push result, 101, to `pi` stack 
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 101, 
                                                    # to ASCII, 'e', and print

# d
pikachu pikachu pika pikachu                        # convert top of `pika` stack, 100, 
                                                    # to ASCII, 'd', and print

# "!" (exclaimation point)
pika pi                                             # copy top of `pika` stack, 10, to `pi` stack
pi pi pika pi pikachu                               # push 3 to `pi` stack
pi pika                                             # copy top of `pi` stack, 3, to `pika` stack
pi pikachu pi pikachu                               # multiply top two elements of `pi` stack
                                                    # push result, 30, to `pi` stack
pika pi                                             # copy top of `pika` stack, 3, to `pi` stack
pi pika pi pikachu                                  # add top two elements of `pi` stack
                                                    # push result, 33, to `pi` stack
pikachu pikachu pi pikachu                          # convert top of `pi` stack, 33, 
                                                    # to ASCII, '!', and print
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Grocery List, 94 bytes

H

w
nnn
d
v
d
v
l
c
u
v
r
v
o
c
u
v
W
nn
c
c
m
c
m
m
w
nnn
c
m
d
nnnn
m
b
b
c
v
e
v
H
l
p
e
t
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Could you please link to the interpreter you used to test this? \$\endgroup\$ – Dennis Jan 2 '19 at 12:34
  • \$\begingroup\$ From the challenge spec: Note that there must be an interpreter so the submission can be tested. The only interpreter I know of is this one, but your program just prints H in it. \$\endgroup\$ – Dennis Jan 2 '19 at 12:59
  • \$\begingroup\$ fixed, but space can't print \$\endgroup\$ – u-ndefined Jan 2 '19 at 13:29
  • \$\begingroup\$ The output looks fine now, but the program seems to exit by popping from an empty stack and the challenge says The program must not write anything to STDERR. \$\endgroup\$ – Dennis Jan 2 '19 at 13:40
1
8 9
10
11 12
27

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