525
\$\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 = (function(){ var headerTag = String.raw `h\d` var score = String.raw `\-?\d+\.?\d*` // with negative/floating-point support var normalText = String.raw `[^\n<>]*` // no HTML tag, no newline var strikethrough = String.raw `<s>${normalText}</s>|<strike>${normalText}</strike>|<del>${normalText}</del>` var noDigitText = String.raw `[^\n\d<>]*` var htmlTag = String.raw `<[^\n<>]+>` return new RegExp( String.raw `<${headerTag}>`+ String.raw `\s*([^\n,]*[^\s,]),.*?`+ String.raw `(${score})`+ String.raw `(?=`+ String.raw `${noDigitText}`+ String.raw `(?:(?:${strikethrough}|${htmlTag})${noDigitText})*`+ String.raw `</${headerTag}>`+ String.raw `)` ); })(); 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, }); }); 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('<i>' + a.language + '</i>').text().toLowerCase(); languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link, uniq: lang}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.uniq > b.uniq) return 1; if (a.uniq < b.uniq) 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} #answer-list { padding: 10px; float: left; } #language-list { padding: 10px; 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/primary.css?v=f52df912b654"> <div id="language-list"> <h2>Winners 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><a href="{{LINK}}">{{SIZE}}</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr> </tbody> </table>

\$\endgroup\$
26
  • 4
    \$\begingroup\$ @isaacg No it doesn't. I think there would be some interesting languages where it's not obvious whether primality testing is possible. \$\endgroup\$ Commented Aug 28, 2015 at 13:56
  • 7
    \$\begingroup\$ If the same program, such as "Hello, World!", is the shortest in many different and unrelated languages, should it be posted separately? \$\endgroup\$ Commented Aug 28, 2015 at 15:33
  • 2
    \$\begingroup\$ @aditsu Yes, because there's no way anyone to find to the shortest version in an answer of an unrelated language. \$\endgroup\$ Commented Aug 28, 2015 at 15:39
  • 3
    \$\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\$ Commented Aug 28, 2015 at 19:34
  • 9
    \$\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\$ Commented Aug 29, 2015 at 23:01

1021 Answers 1021

1
\$\begingroup\$

m68k machine language (tested on SunOS 4.1.4) 42 40 36 bytes

0x00 4878000d pea 13 ; push length of string to stack 0x04 610e bsr 0x14 ; push address of string to stack 0x06 48656c6c "Hello, World!\0" ; string 0x0a 6f2c2057 0x0e 6f726c64 0x12 2100 0x14 48780001 pea 1 ; push fd=1 "stdout" to stack 0x18 48780001 pea 1 ; push extra stack slot 0x1c 48780004 pea 4 ; select "write()" syscall 0x20 4e40 trap #0 ; call "write()" 0x22 4e40 trap #0 ; call "exit()" ; write() leaves 1 on stack which is ; used to select exit() syscall. 

SunOS appears to be fairly permissive when it comes to arguments of the trap instruction on m68k so this may (untested) work unmodified on NetBSD for m68k.

To try it out, compile and run the following C program.

int main[]={0x4878000d,0x610e4865,0x6c6c6f2c,0x20576f72, 0x6c642100,0x48780001,0x48780001,0x48780004,0x4e404e40}; 
\$\endgroup\$
1
  • \$\begingroup\$ the catalogue accidentally used the last number in the title so it equals to 1.4 bytes \$\endgroup\$ Commented Nov 15, 2024 at 20:16
1
\$\begingroup\$

AutoHotkey (v2), 30 bytes

FileAppend "Hello, World!","*" 

AHK is designed for GUI apps. It won't attache the current console by default. Need to call with piping:

> autohotkey hello.ahk | echo Hello, World! 
\$\endgroup\$
1
\$\begingroup\$

SqueezeL, ceil(20 * 2/3) = 14 bytes

")hello)18 )world)0x 
\$\endgroup\$
1
\$\begingroup\$

StackCell, 20 bytes

"!dlorW ,olleH":[;:] 
\$\endgroup\$
1
\$\begingroup\$

Jalapeño, 14 bytes

l¿47?+{₅¿4c?Iₓ¿43?¬w◹₋Cₓ⇥ₓ¿4b?" 

Just the raw string as a base 254 string.

Hex-Dump of Bytecode

 0 1 2 3 4 5 6 7 8 9 A B C D E F 0000: 6d 47 50 c9 4c 94 43 58 18 76 c3 df 4b 20 

Try it Online!

\$\endgroup\$
1
\$\begingroup\$

UNAI, 15 bytes

Array? has been rebranded into UNAI

"Hello, World!" 
\$\endgroup\$
0
1
\$\begingroup\$

ppencode, 273 bytes; 73 words

print uc chr ord qw x hex and eval q y print chr ord foreach qw x else lt lt or x y xor print chr oct oct ord uc qw q bind q and print q q q and print chr ord uc q qw q and eval q y print chr ord for qw x or read lt do x y xor print chr hex length q q getprotobynumber lt q 

Try it online!

Ungolfed

# print "H" print uc chr ord qw x hex and # print foreach qw[e l l o] eval q y print chr ord foreach qw x else lt lt or x y xor # print "," print chr oct oct ord uc qw q bind q and # print " " print q q q and # print "W" print chr ord uc q qw q and # print for qw[o r l d] eval q y print chr ord for qw x or read lt do x y xor # print "!" print chr hex length q q getprotobynumber lt q 
\$\endgroup\$
1
\$\begingroup\$

SAKO, 34 bytes

1)TEKST Hello, World! STOP1 KONIEC 

I don't think it needs an explanation.
I believe this is optimal and cannot be shortened, but you can prove me wrong.

\$\endgroup\$
1
  • 1
    \$\begingroup\$ Welcome to Code Golf Stack Exchange, nice solution, interesting language \$\endgroup\$ Commented Mar 14 at 16:45
1
\$\begingroup\$

Emmental, 68 61 54 51 bytes

-7 bytes thanks to @Adelie!
-7 bytes thanks to @Adelie!
-3 bytes

#72.#101.#108::..#111:.#44.#32.#87..#114..#100.#33. 

Try it online!

All I know is that each of those numbers represent Ascii characters (you have to put them in reverse for it to work, so that gives the input !dlrow ,olleH), and then the .s pop them off from right to left.

Golf 1: #0#10 (trailing newline) is apparently optional (-4), had a duplicate # between 108 and 101 apparently (-5), deleted two unneeded . (-7)

Golf 2: Done using duping and using the queue

Golf 3: Using the queue is not as useful as it seems, now that I have golfed this without it. Hopefully I can get sub-50 soon.

\$\endgroup\$
3
  • \$\begingroup\$ Nice, but the capitalization of the w is incorrect. You also don't need the #0#10 since a trailing newline is optional, nor the duplicate # between 108 and 101, so you should be able to save 8 bytes. \$\endgroup\$ Commented May 31, 2024 at 17:19
  • \$\begingroup\$ 54 bytes by duping and using the queue \$\endgroup\$ Commented Jun 2, 2024 at 9:34
  • \$\begingroup\$ @Adelie I've saved 3 bytes since then without using the queue. Admittedly I don't see any way I could golf this unless I can somehow rearrange what/when I push to the stack, or if I could somehow manipulate the queue even further. \$\endgroup\$ Commented Apr 3 at 16:03
1
\$\begingroup\$

smotslang -s, 208 bytes

212 -> 208 by using decimal literal

crumble 'H retry crumble 'e retry crumble 'l retry retry crumble 'o retry crumble ', retry crumble ^32 retry crumble 'W retry crumble 'o retry crumble 'r retry crumble 'l retry crumble 'd retry crumble '! run 

Has to be simple because (unfortunately) memory usage makes it too long.

Explained:

crumble 'H retry -- Output 'H' -- crumble 'e retry crumble 'l retry retry -- Output 'l' twice -- crumble 'o retry crumble ', retry crumble ^32 retry -- 32 in hex is 0x20; output '\x20' -- crumble 'W retry crumble 'o retry crumble 'r retry crumble 'l retry crumble 'd retry crumble '! run 

retry vs run?
retry just outputs (format depends on -s, see below). It won't have a trailing newline though, only run has that.

Why -s?
Without -s all the code points would be outputted instead, yielding 7210110810811144328711111410810033. Not great for this case. If you really want no flags, then add reload to the start for an extra 7 bytes.

This answer is #2 of my smotslang challenge sweep

\$\endgroup\$
1
\$\begingroup\$

Arsla, 15 bytes

"Hello, World!" 

The string gets stored into the stack and gets into output. Hello World program in Arsla

Arsla, 17, 16 bytes

"Hello, World!"p 

The string is shown in stdout. The space between string is negligible. Hello World program not stored in stack

\$\endgroup\$
1
\$\begingroup\$

OpenRISC or1k (big endian) machine language on Linux, 48 45 42 bytes

0x00: 04 00 00 02 l.jal <0x08> ; PC rel jmp, return addr to r9 0x04: 9c 60 00 01 l.addi r3,r0,1 ; delay slot; fd=1 0x08: 9c 89 00 15 l.addi r4,r9,21 ; put addr of string in r4 0x0c: 9c a0 00 0d l.addi r5,r0,13 ; length of string 0x10: 9d 60 00 40 l.addi r11,r0,64 ; select write() syscall 0x14: 20 00 00 01 l.sys 0x1 ; call write() 0x18: 9d 60 00 5d l.addi r11,r0,93 ; select exit() syscall 0x1c: 20 48 65 6c l.sys 0x656c ; call exit() 0x20: 6c 6f 2c 20 ; "Hello, World!" 0x24: 57 6f 72 6c 0x28: 64 21 

EDIT: Linux kernel appears to tolerate l.sys with arguments other than 0x1. The online simulator and OR1200 RTL appear to recognize opcode 0x2048 as an l.sys instruction.

To try this on an OpenRISC machine or online simulator, compile and run the following c program

const main[]={0x04000002,0x9c600001,0x9c890015,0x9ca0000d, 0x9d600040,0x20000001,0x9d60005d,' Hel', 'lo, ','Worl','d!\0\0'}; 
\$\endgroup\$
1
\$\begingroup\$

Rewriten 4ME, 19 18 bytes

echo{Hello, World! 

Try it online

\$\endgroup\$
1
\$\begingroup\$

Normal 4ME, 21 bytes

P; out{Hello, World!} 

Normal 4ME actually requires the brackets to be matched up so...

the proof that this program works

fun fact about Normal 4ME:

most of the code writen in the implementation is AI Generated due to the fact i had barely any good experience in coding

\$\endgroup\$
1
\$\begingroup\$

How dare you fuck the brain -c, 166 159 157 155 (153+2) bytes

This is the problem with HDYFTB. Printing strings is really annoying

IIII=+=+=+=+IIIIIIIIP=DDDP^IIIIPPIIIP^IIII=+=+=+^IIII=+=+DDDDv+P|DvD^)IIII=+=+=+P=+^IIII=+=+v+IIIIIIIP=|vD^D)^DDDDDDDDv+P=IIIP^DDDP^DDDD=+v+P^IIII=+=+=+I 

Try it online

\$\endgroup\$
2
  • \$\begingroup\$ reading into this language, esolangs page says its meant to be a golfy version of brainfuck... is there a way to port the 72 byte brainfuck solution? \$\endgroup\$ Commented Dec 15, 2024 at 18:48
  • 1
    \$\begingroup\$ it wasn't ment to be a golfing language. The category section even says that \$\endgroup\$ Commented Dec 15, 2024 at 19:28
1
\$\begingroup\$

Intel ASM 150 bytes

Found this when I tried making my own OS a few years back. Isn't golfed down at all

[bits 16] [org 0x7c00] mov si,c mov ah,0x0e a: lodsb cmp al,0 je b int 0x10 jmp a b: hlt c: db "Hello, World!",0 times 510-($-$$) db 0 dw 0xaa55 

Compile using nasm, run with qemu-system-x86_64.

\$\endgroup\$
1
\$\begingroup\$

6502 machine language (position independent code) on Commodore 8-bit, 60 bytes

0000 78 SEI ; stop interrupts; stack shenanigans ahead! 0001 20 B7 FF JSR $FFB7 ; call CLALL just to get the program counter saved in the stack 0004 A9 BD LDA #$BD ; build LDA ($xxxx),X on the bottom of the stack 0006 8D 00 01 STA $0100 0009 BA TSX ; pointer to program counter in X 000a CA DEX 000b A9 2B LDA #$2B ; offset where "Hello, World!" string is 000d 18 CLC 000e 7D 00 01 ADC $0100,X 0011 8D 01 01 STA $0101 ; store LSB of string address 0014 E8 INX 0015 A9 00 LDA #$00 ; load MSB of program counter 0017 7D 00 01 ADC $0100,X ; add 1 if there was a carry from adding string offset 001a 8C 02 01 STA $0102 ; store MSB of string address 001d A9 60 LDA #$60 ; put an RTS after the LDA on the stack 001f 8D 03 01 STA $0103 0022 58 CLI ; safe to turn interrupts back on 0023 A2 0D LDX #$0D ; length of string 0025 20 00 01 JSR $0100 ; call code snippet we just placed on the bottom of the stack 0028 20 D2 FF JSR $FFD2 ; call CHROUT to output character 002b CA DEX ; iterate through string backwards 002c D0 F7 BNE $0025 002e 60 RTS 002f 21 44 4C "!dlroW ,olleH" 0032 52 4F 77 0035 20 2C 4F 0038 4C 4C 45 003B 68 

This program is fully relocatable, even across page boundaries. This constructs a 4 byte trampoline-like snippet LDA (STRING_ADDR),X; RTS on unused stack space that copies a character from the string to the accumulator before calling CHROUT. This does not make use of the zero page.

To try this on an 8 bit Commodore computer, type in and run the following BASIC program. Try changing the value of ADDR to any valid RAM address (that doesn't overwrite anything too important).

10 PRINT CHR$(14) 20 ADDR = 260 70 FOR I=0 TO 59 75 READ A: POKE ADDR+I,A 80 NEXT 90 SYS ADDR 100 DATA120,32,183,255,169,189,141,0,1,186 110 DATA202,169,43,24,125,0,1,141,1,1 120 DATA232,169,0,125,0,1,141,2,1,169 130 DATA96,141,3,1,88,162,13,32,0,1 140 DATA32,210,255,202,208,247,96,33,68,76 150 DATA82,79,119,32,44,79,76,76,69,104 
\$\endgroup\$
2
  • \$\begingroup\$ Have you run this program? My first program was a basic Vic20 commodore computer, was the first time I have seen all the data after the basic program, and they said are assembly instructions. Here say 3b-b=30 is it sure the 2b distance from the start of string? Or better it is 3B-D=2e \$\endgroup\$ Commented Oct 28 at 7:25
  • 1
    \$\begingroup\$ @Rosario I tested it on an (emulated) VIC-20 with ADDR set to values such as 260 and 7000. The offset is counted from the LDA instruction at $0004 in the listing. 0x2b + 0x04 = 0x2f which is where the string starts. \$\endgroup\$ Commented Oct 28 at 18:06
0
\$\begingroup\$

rs, 14 bytes

/Hello, World! 

Replaces the empty string with "Hello, World!"

\$\endgroup\$
0
\$\begingroup\$

WARP, 16 bytes

)"Hello, World!" 

) is the standard output mechanism.

\$\endgroup\$
0
\$\begingroup\$

ACIDIC, 16 bytes

Hello, World! +* 

Prints the entire storage stack, which is filled with Hello, World!.

\$\endgroup\$
0
0
\$\begingroup\$

Ans, 16 bytes

$"Hello, World!" 

$ is the standard output mechanism.

\$\endgroup\$
0
\$\begingroup\$

J--, 28 bytes

main{echo("Hello, World!");} 

main is replaced with public static void main(String[]a), echo is replaced with System.out.println, and the entire program is put in a class.

\$\endgroup\$
0
\$\begingroup\$

A0A0, 57 bytes

P72P87 P101P111 P108P114 P108P108 P111P100 P44P33 P32 G-6 

2 commands per line was the densest packing that I could find.

\$\endgroup\$
2
  • \$\begingroup\$ I get Hl,Wrdeo ol! as the output from this... \$\endgroup\$ Commented Sep 28, 2015 at 12:47
  • \$\begingroup\$ @Sp3000 Should be fixed \$\endgroup\$ Commented Sep 28, 2015 at 20:57
0
\$\begingroup\$

STXTRM, 15 bytes

[Hello, World!] 

[...] is the standard output mechanism.

\$\endgroup\$
0
\$\begingroup\$

Argh!, 27 bytes

ppppppppppppp Hello, World! 

Each p prints the character below it.

\$\endgroup\$
0
\$\begingroup\$

AutoIt, 29 bytes

ConsoleWrite("Hello, World!") 

Needs to be compiled as a console program.

\$\endgroup\$
1
  • \$\begingroup\$ MsgBox(0,"","Hello, World!") is one shorter :) \$\endgroup\$ Commented May 8, 2019 at 20:37
0
\$\begingroup\$

Foobar and Foobaz and Barbaz, oh my!, 314 bytes

72 and 72 and 0, oh my. 37 and 37 and 64, oh my. 72 and 72 and 36, oh my. . and 64 and 44, oh my. 67 and 67 and 44, oh my. . and 44 and 0, oh my. . and 32 and 0, oh my. 87 and 87 and 0, oh my. 40 and 40 and 71, oh my. 16 and 16 and 98, oh my. 12 and 12 and 96, oh my. . and 64 and 36, oh my. 1 and 1 and 32, oh my. 

I believe that this is an optimal solution, with each line outputting a character.

\$\endgroup\$
0
\$\begingroup\$

Tarflex, 18 bytes

outs Hello, World! 

outs is the standard output mechanism.

\$\endgroup\$
0
\$\begingroup\$

SSBPL, 33 bytes

0'!'d'l'r'o'W' ','o'l$'e'H[$][.]# 

This pushes the ASCII for "Hello, World!" followed by a 0 onto the stack, then prints the top value while it isn't zero.

\$\endgroup\$
0
\$\begingroup\$

Super Stack!, 66 bytes

0 33 100 108 114 111 87 32 44 111 108 108 101 72 if outputascii fi 

Pushes the letters followed by a zero onto the stack, and prints them while they aren't zero.

\$\endgroup\$

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.