Tictac, 2 bytes

?h

Attempt it Online!

Hmm yes just another one of those konstant style answers.

14 bytes

"Hello, World!

Lol

Haifuckqueue, 59 bytes

{Hel}
$3{lo,}
$3{ }
$1{W}
$1{orl}
$3ooo
ooooo
{d!}$2o
ooooo

Explanation:

{Hel}   -- overwrite top 3 bytes as ascii of "Hel"
$3{lo,} -- print top 3 items as characters and push ascii of "lo," to the stack
$3{ }
$1{W}
$1{orl}
$3ooo   -- print top 3 items as chars and pad with "o" (xor top 2 items and put result in 3) for haiku 5 7 5
ooooo
{d!}$2o -- top 2 and pad more o
ooooo

Try it online!

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 '!'

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)

FIM++, 87 bytes

I golfed off one byte: the original was by @martinender. I golfed off a space between a token said and a symbol ".

Dear Princess Celestia:A.Today I learned:I said"Hello, World!".Your faithful student,B.

Try it online!

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

RickRoll-Lang, 70 59 bytes

no interpreter on tio so i cloned the repo on replit lol

takemetourheart
ijustwannatelluhowimfeeling "Hello, World!"

Explanation:

RickRoll-Lang keywords do not need spaces between them

takemetourheart                             -- "main()" function declaration
ijustwannatelluhowimfeeling "Hello, World!" -- print the string "Hello, World!"
                                            -- implicit "say goodbye" (end block) at the end

Try it online!

PICO-8, 32 bytes

?"h69767679, w79827668!"

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:

?"h69*27679, w79827668!"

Paradoc, 15 bytes

first paradoc solution lol

"Hello, World!"

Try it online!

Aussie++, 34 bytes

G'DAY MATE!
GIMME "Hello, World!";

Tested in commit 0a5de7e. You're supposed to end the program with CHEERS C***!, but as of that commit it isn't strictly necessary. The opening G'DAY MATE!, with trailing whitespace, is; anything before that statement is not executed.

Hello Hell, 0 bytes

Since the tape is initialized to "Hello, World!", and the contents of the tape are printed automatically at the end of execution, the blank program is a Hello World program.

ErrLess, 17 bytes

SHello, World!S?.

Prints Hello, World! to stdout, without a trailing newline.

ErrLess is a stack-based language I made for fun over the last few months. You can read the docs here, and I also started a tutorial.

Try it online!

Logomocja, 20 bytes

pisz [Hello, World!]

Logomocja is the Polish dialect of Logo, pic related shows the effect of executing the command in its environment

// TODO: fix, 51 bytes

//TODO:idea:"Hello, World!"TODO:this code is cursed

// TODO: fix is a joke language with commands that look like "TODO" comments in source code, created by RocketRace for JT's langjam.

• // TODO: idea: "string" pushes a string literal
• // TODO: this code is cursed outputs that string

The language isn't really designed for golfing, but a bit of fiddling with the syntax got this down to 51 bytes. Here is a more "idiomatic" example taken from the language's README:

use std::io::{stdout, Write};
// TODO: someone on the internet told me "Hello, world!" is a good idea
fn hello() {
    let chars = &[
        'n', '!', 'd', 'l', 'r', 'o', 'w', ' ', ',', 'o', 'l', 'l', 'e', 'H'
    ];
    let mut out = stdout();
    // TODO: somehow fix this cursed code
    for c in chars.iter().rev() {
        let mut buf = vec![0; 4];
        c.encode_utf8(&mut buf).unwrap();
        out.write(&buf).unwrap();
    }
    out.flush.expect("unwrap");
}

(the language simply ignores everything except the TODOs)

Vim, 14 bytes

iHello, World!

Try it online!

قلب repl, 21 bytes

قول"Hello, world!"

Online repl

Qalb is a programming language designed for Arabic speakers as opossed to the anglophone stance of most popular programming languages.

I took this program from wikipedia and fiddled around with it, managing to save 3 bytes. If you were wondering, قول means "say".

I haven't managed to get a full implementation running on my computer so for now I am just using the repl.

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(/rn|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(/rn|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>

CLC-INTERCAL, 221 bytes.

DO;1<-#13DO;1SUB#1<-#29DO;1SUB#2<-#1100DO;1SUB#3<-#249DO;1SUB#4<-#255DO;1SUB#5<-#250DO;1SUB#6<-#677DO;1SUB#7<-#373DO;1SUB#8<-#4160DO;1SUB#9<-#570DO;1SUB#10<-#2572DO;1SUB#11<-#225DO;1SUB#12<-#247DO;1SUB#13<-#348DOREADOUT;1

How I generated the code above.

There is other "Hello, World!" program that uses a tail array, but it has 278 bytes when I do these:

• Remove GIVE UP statement
• Replace PLEASE with DO, as politeness doesn't matter in CLC-INTERCAL
• Remove every space and LF.

I think this is the only site that you can try CLC-INTERCAL online.

Edit. As of 1.-94.-2, politeness is not checked, unlike INTERCAL-72 and CLC-INTERCAL.

abcn, 92 bytes

aaaac018gxnaaaaac020agxaaaaaaagxgxaaagxnaaaac008gxbbc004bgxbbbbbbbbgxaaagxbbbbbbgxbbbbbbbbgx

Obviously not the shortest answer by a mile but for me its fine.

Now how does this work

aaaac018gxn  H --> 72
aaaaac020agx E --> 101
aaaaaaagx    L --> 108
gx           L --> 108 
aaagxn       O --> 111
aaaac008gx   SPACE ---> 32
bbc004bgx    W  --> 119
bbbbbbbbgx   O  --> 111
aaagx        R  --> 114
bbbbbbgx     L  --> 108
bbbbbbbbgx   D  --> 100

For reference a inc accumulator by 1, b decs by 1 and c is for multiplication g converts to ASCII and x prints

(I do have an interpreter, clicking the link leads to it but you are gonna have to test it yourself)

NOTE : language is WIP

Tarfish, 160 bytes

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

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

No TIO yet.

Minim, 44 43 42 Bytes

New solution uses the Carriage Return escape character 'r', saving 1 more byte:

[]="r!dlroW ,olleH".$<[[0]--]._^![0].C=0.

Thanks to @stasoid for the incidental? realization!

With whitespace and comments:

[] = "r!dlroW ,olleH". ; Insert the value 13, and "Hello, World!" backwards, 
                          into memory starting from index 0
$< [[0]--].             ; Prints the value at the index stored at index 0 as unicode, 
                          and decrements index 0
_^ ![0].                ; Skip the next statement if index 0 is 0
C = 0.                  ; Sets the program counter to 0, which advances to 1 afterwards

Previous solutions prepended the string with 13...

[]=13&"!dlroW ,olleH".$<[[0]--]._^![0].C=0.

... or used ASCII escape character 0xD (CR) in the string:

[]="x0D!dlroW ,olleH".$<[[0]--]._^![0].C=0.

GitHub Repository

Arduino, 75 bytes

void setup(){Serial.begin(300);Serial.print("Hello, World!");}void loop(){}

Although Arduino does have println(), the challenge said the newline is optional, and print() is shorter.

文言 / wenyan‑lang, 55 bytes

吾有一言。曰「「Hello, World!」」。書之。

Try it Online! (Online interpreter/IDE, I don't think there's a way to share code directly but just copy and paste into the editor and press Run)

For the "Hello, World!" in Classical Chinese example wenyan-lang themselves give (60 bytes):

吾有一言。曰「「問天地好在。」」。書之。

51AC8, 2 bytes

Kh

Try it Online!

Finally an online interpreter. A little quirk you have to press Run twice.

GForth 17 Bytes

." Hello, World!"

S3C, 13 bytes

Hello, World! returns Hello, World! This is a fairly new esolang, but it works for golfing.

brainbox, 118 bytes

 ++++<!.+aa.--------.------.+++.d.-d.------------.++++++++++++aa.+++..+++++++.---w.dd]-sa-a+w+d]-ds+a+++a+++w++d[++++d

Try it Online!

I've finished my new language, called brainbox! It's a 2D extension of brainfuck, with a 2D grid for the code and a 2D grid for the memory. This program is a modification of the "Hello World!" program in brainfuck found on esolangs.org. I used a few features to shorten it:

• Instead of using ++++++++ to set the first cell to 8, I used ++++<, which is 3 bytes shorter and changes the IP direction to the left.

• I made use of the 2D memory space in order to reduce the number of commands needed to move the memory pointer around.

• I also used an unmatched ] to loop execution back to (0,0). This doesn't actually save any bytes here, but I wanted to show off that feature.

For more information on the language and some of the features and quirks, check out the GitHub repo.

ARM (Thumb), 29 bytes

Assembly:

.section .text
.global _main
.thumb
_main:
    mov r7, #4         // 2704   syscall #4 (write)
    mov r0, #1         // 2001   fd #1 = stdout
    add r1, pc, #8     // a102   string address = (pc+4) + 8 (msg)
    mov r2, #13        // 220d   string length = 13
    svc #0             // df00   write(1, msg, 13)

    mov r7, #1         // 2701   syscall #1 (exit)
    mov r0, #0         // 2000   exit code 0
    svc #0             // df00   exit(0)

msg: .ascii "Hello, World!" // 13 bytes, without trailing newline

How to run this on Ubuntu:

sudo apt-get install qemu-user qemu-user-static build-essential gcc-arm-linux-gnueabihf binutils-arm-linux-gnueabihf binutils-arm-linux-gnueabihf-dbg
# build and run as Thumb executable
arm-linux-gnueabihf-as main.as -o main.o
arm-linux-gnueabihf-ld --thumb-entry=_main main.o -o main
qemu-arm -L /usr/arm-linux-gnueabihf ./main
# see disassembly and calculate machine code size
arm-linux-gnueabihf-objdump -d main

Most parts of the instructions and the code structure are from this guide. A full Thumb instruction set reference can be found in this pdf, but I couldn't find any easier-to-lookup reference.

25 bytes (exits by segfault)

.section .text
.global _main
.thumb
_main:
    mov r7, #4         // 2704   syscall #4 (write)
    mov r0, #1         // 2001   fd #1 = stdout
    add r1, pc, #4     // a102   string address = (pc+4) + 4 (msg)
    mov r2, #13        // 220d   string length = 13
    svc #0             // df00   syscall
    nop                // 46c0   for 4-byte alignment of msg

msg: .ascii "Hello, World!"

While it is possible to call puts and similar by dynamically linking to libc, I don't think it's fair to discount the glue code generated by the linker (single puts call adds 36 bytes as section .plt).

Regenerate, 14 bytes

Hello, World!

Try it here!

Regenerate is my new regex-match-generation language. The hello world program is pretty simple: just the literal string as a regex, with the ! escaped because it's a metacharacter.

BrainCrash, 14 bytes.

Note that this is NOT Braincrash; this is also a Brainfuck-variant, with these expansions:

• The first 13 cells are initially Hello, world!.
• Automatically implicit output.
• Four logical operators.

Here is the program:

>>>>>>^<<<<<<<

What it does

• Move to space.
• ^ is mem[ptr+1]=mem[ptr] xor mem[ptr+1]; ptr++;; to change w with W.
• Go back.
• Implicit [.>]

Try it online! The interpreter was originally written by "ぬこ", the designer of the language; I modified a bit for TIO.

RAMDISP, 18 bytes.

[;[Hello, World!]]

explanation:

[; - print the following values, stringified, and joined.
  [Hello, World!] - an array containing ['H', 'e', 'l', ...]
]

All of these answers are pretty boring (one is a built-in and the string compression algorithm isn't even my own); consider upvoting some cool answers in tarpits / esolangs rather than this one. I'm just putting it here to have yuno officially be a language on CGCC, and because Hello, World! is a good entry point for any language.

yuno, 1 byte

ᴋ

Try it online!

By default, if the k-literal digraph finds no character after it, it just uses H, because I haven't thought of a good behavior for it otherwise so I may as well save bytes on Hello World.

yuno, 2 bytes

ᴋH

Try it online! Uses the built-in string nilad digraph (inspired by Vyxal).

yuno, 8 bytes

“3ԸaϨ;ψ»

Try it online! Uses a compressed string with the exact same compression algorithm that Jelly uses.

yuno, 15 bytes

“Hello, World!”

Try it online! A default string. As caird coinheringaahing points out, the trailing ” can be removed if it occurs at the end of the program.

Windows Portable Executable 32 bit, 268 bytes

xxd:

00000000: 4d5a 0000 5045 0000 4c01 0100 0000 0000  MZ..PE..L.......
00000010: 0000 0000 0000 0000 7000 0301 0b01 0000  ........p.......
00000020: 0000 0000 0000 0000 0000 0000 b400 0000  ................
00000030: 0000 0000 0000 0000 0000 4000 0400 0000  ..........@.....
00000040: 0400 0000 0000 0000 0000 0000 0400 0000  ................
00000050: 0000 0000 0004 0000 0100 0000 0000 0000  ................
00000060: 0300 0000 0000 0000 0000 0000 0000 0000  ................
00000070: 0000 0000 0000 0000 0200 0000 0000 0000  ................
00000080: 0000 0000 e600 0000 0000 0000 2e74 6578  .............tex
00000090: 7400 0000 4600 0000 b400 0000 4600 0000  t...F.......F...
000000a0: b400 0000 0000 0000 0000 0000 0000 0000  ................
000000b0: 0000 0000 68c5 0040 00ff 15da 0040 00ff  ....h..@.....@..
000000c0: 15de 0040 0048 656c 6c6f 2c20 576f 726c  [email protected], Worl
000000d0: 6421 0063 7274 646c 6c00 bb01 0080 6701  d!.crtdll.....g.
000000e0: 0080 0000 0000 0000 0000 0000 0000 0000  ................
000000f0: 0000 d300 0000 da00 0000 0000 0000 0000  ................
00000100: 0000 0000 0000 0000 0000 0000            ............

source:

; nasm

BITS 32
base equ 0x400000

;
; DOS header
;
; The only two fields that matter are e_magic and e_lfanew

mzhdr:
    dw "MZ"       ; DOS e_magic
    dw 0

;
; NT headers
;

    dd "PE"       ; PE signature

;
; NT file header
;

filehdr:
    dw 0x014C            ; Machine (Intel 386)
    dw 1                 ; NumberOfSections
    dd 0                 ; TimeDateStamp UNUSED
    dd 0                 ; PointerToSymbolTable UNUSED
    dd 0                 ; NumberOfSymbols UNUSED
    dw opthdrsize        ; SizeOfOptionalHeader
    dw 0x103             ; Characteristics

;
; NT optional header
;

opthdr:
    dw 0x10B                    ; Magic (PE32)
    db 0                        ; MajorLinkerVersion UNUSED
    db 0                        ; MinorLinkerVersion UNUSED
    dd 0                        ; SizeOfCode UNUSED
    dd 0                        ; SizeOfInitializedData UNUSED
    dd 0                        ; SizeOfUninitializedData UNUSED
    dd start                    ; AddressOfEntryPoint
    dd 0                        ; BaseOfCode UNUSED
    dd 0                        ; BaseOfData UNUSED
    dd base                     ; ImageBase
    dd 4        ; DOS e_lfanew  ; SectionAlignment
    dd 4                        ; FileAlignment
    dw 0                        ; MajorOperatingSystemVersion UNUSED
    dw 0                        ; MinorOperatingSystemVersion UNUSED
    dw 0                        ; MajorImageVersion UNUSED
    dw 0                        ; MinorImageVersion UNUSED
    dw 4                        ; MajorSubsystemVersion
    dw 0                        ; MinorSubsystemVersion UNUSED
    dd 0                        ; Win32VersionValue UNUSED
    dd 1024                     ; SizeOfImage
    dd 1                        ; SizeOfHeaders          nonzero for Windows XP
    dd 0                        ; CheckSum UNUSED
    dw 3                        ; Subsystem (Console)
    dw 0                        ; DllCharacteristics UNUSED
    dd 0                        ; SizeOfStackReserve
    dd 0                        ; SizeOfStackCommit
    dd 0                        ; SizeOfHeapReserve
    dd 0                        ; SizeOfHeapCommit UNUSED
    dd 0                        ; LoaderFlags UNUSED
    dd 2                        ; NumberOfRvaAndSizes    for Windows 10; UNUSED in Windows XP

;
; Data directories (part of optional header)
;
    dd 0, 0                     ; Export Table UNUSED
    dd idata, 0                 ; Import Table

opthdrsize equ $ - opthdr

;
; Code section header
;

    db ".text", 0, 0, 0         ; Name
    dd codesize                 ; VirtualSize
    dd code                     ; VirtualAddress
    dd codesize                 ; SizeOfRawData
    dd code                     ; PointerToRawData
    dd 0                        ; PointerToRelocations UNUSED
    dd 0                        ; PointerToLinenumbers UNUSED
    dw 0                        ; NumberOfRelocations UNUSED
    dw 0                        ; NumberOfLinenumbers UNUSED
    dd 0                        ; Characteristics UNUSED

;
; Code section data
;

align 4, db 0

code:

;
; Entry point
;

start:
    push base + msg
    call [base + puts]
    call [base + exit]

msg:
    db "Hello, World!",0

crt:
    db "crtdll",0

;
; Import address table (array of IMAGE_THUNK_DATA structures)
;

iat:
puts:   dd 0x800001BB           ; Import puts by ordinal
exit:   dd 0x80000167           ; Import exit by ordinal
        dd 0                    ; terminator

;
; Import table (array of IMAGE_IMPORT_DESCRIPTOR structures)
;

idata:
    dd 0                        ; OriginalFirstThunk UNUSED
    dd 0                        ; TimeDateStamp UNUSED
    dd 0                        ; ForwarderChain UNUSED
    dd crt                      ; Name
    dd iat                      ; FirstThunk

    ; terminator
;    times 5 dd 0 ; too big, padding serves as terminator

codesize equ $ - code

;
; Padding for Windows 10
;
    times 268 - ($-$$) db 0

Previous PE answer: 1175 bytes.

This program was tested on Windows 10 2004 64-bit and Windows XP SP3.

The answer is based on this article, which creates the smallest PE file on Windows XP. I took the smallest file that works on Windows 10 from tinype.zip, which is tiny.296, and added imports using tiny.import.209. Other useful articles: one two.

Quirks:

Windows 10:

• 268 byte size limit (link)
• imports must be in a section (link), that's why codesize includes imports

Windows XP:

• ignores NumberOfRvaAndSizes, it's not a problem because Debug Directory size happens to be 0 (Characteristics field of .text section header) (link)
• SizeOfHeaders must be nonzero

I think 268 = 4 + 264, where 4 is the minimal offset of NT headers from the start of the file and 264 is the minimal distance between the start of NT headers and end of file. 264 is probably sizeof(IMAGE_NT_HEADERS32)+16 or sizeof(IMAGE_NT_HEADERS64). Because Windows 10 imposes hard limit on minimal PE size, there is no need to cram section header, code and imports into NT headers.

Of the four CRT libraries that are available on both XP and 10 (crtdll.dll, msvcrt.dll, msvcrt20.dll, msvcrt40.dll), I use crtdll.dll because it has a shorter name and has not been updated since 1995, so (it feels like) it's safe to import by ordinals from it. There is no big problem to import by names, but then those names must be inside headers, which is a bit messier.

The program sometimes hangs if puts is imported and ret is used to exit the program (this is true for both crtdll and msvcrt), so I use exit.

æae, 484 chars

€ââââäââââââââæėâââââäęęęęęęęęęęęęęęęęęęęęęęęęæėâââââäęęęęęęęęęęęęęęęęęæėâââââäęęęęęęęęęęęęęęęęęæėâââââäęęęęęęęęęęęęęęæėâââäâââââââââââââââââæėââââââââââåæėââââäâââââââââââââââââââââââæėâââââäęęęęęęęęęęęęęęæėâââââäęęęęęęęęęęęæėâââââäęęęęęęęęęęęęęęęęęæėâââââäęęęęęęęęęęęęęęęęęęęęęęęęęæ

I've added newlines to clarify which is which:

€                                      < € is required here
ââââäââââââââæ                         < H
ėâââââäęęęęęęęęęęęęęęęęęęęęęęęęæ       < e
ėâââââäęęęęęęęęęęęęęęęęęæ              < l
ėâââââäęęęęęęęęęęęęęęęęęæ              < l
ėâââââäęęęęęęęęęęęęęęæ                 < o
ėâââäâââââââââââââââââæ                < ,
ėââââââââââåæ                          < [space]
ėââââäâââââââââââââââââââââââæ         < W
ėâââââäęęęęęęęęęęęęęęæ                 < o
ėâââââäęęęęęęęęęęęæ                    < r
ėâââââäęęęęęęęęęęęęęęęęęæ              < l
ėâââââäęęęęęęęęęęęęęęęęęęęęęęęęęæ      < d

æae is a language that I made and am implementing as practice for CBL. Github: https://github.com/SMARNAV/aeae/

P'', 62 Bytes

This answer doesn't meet the technical restrictions, because P'' has no I/O, but I think it hasn't been done yet.

+[-->-[>>+>-----<<]<--<---]>->>>+>>+++[>]<<<<+++------<<->>>>+

It is just the shortest known BF answer, but without the I/O, which makes sense, given BF is a derivative of P'' with I/O. Has no output, so an online interpreter won't do much, but just use the TIO BF interpreter to check it doesn't error.

Minecraft 1.16, 36 bytes

Just something I thought of :D

/tellraw @a {"text":"Hello, World!"}

I can't find a try it online for these though

Risky, 64 bytes

22+222]+]2:+1+:++!:++2:+*+1+0+[-*-*+02]+]2{*+++**+}+0!:+*+1+0+:+*+1+!!:+++0+0+:+0+0+0!{*++1+0+]+]+]+]+]+]+]+]+]+]+]+]+]+]+]+]

Try it online!

This is a new language made by @Redwolf Programs. My explanation wouldn't do it justice so heres the Docs.

Explanation:

Takes the various codepoints for various characters and links them together.

Redwolf also created a version of it which is a simpler "tree" layout, which also comes in at 64 bytes:

**}+1+1!0+:+0+1+0+:+0++!0+:+0+++0+:+!++!{**+0+{+!**+0+2!+**+0+}+0+:+!++!:+*+0+{+0+:+0++!0+0+0+:+!**+0+!20+0+0+]+0+0+0+]+0+0+0+]

Try it online!

<>^v, 16 bytes

"Hello, World!";

Pushes the string "Hello, World!" to the stack and prints it.

run online

Incident, 636 bytes

(uses Windows-1252 encoding)

!"#$%&()*+,-0123456789:;<=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“|””>!”••!"•––"#–˜˜#%˜™™%&™››&)›žž)+ž¡¡+-¡¢¢-0¢¥¥03¥¦¦34¦§§45§ªª58ª­­8;­®®;<®¯¯<=¯²²=A²µµADµººDIº½½IL½¾¾LM¾¿¿MN¿ÂÂNQÂÄÄQSÄÅÅSTÅÆÆTUÆÇÇUVÇÈÈVWÈÉÉWXÉÊÊXYÊÌÌY[ÌÍÍ[]ÍÑÑ]aÑÓÓacÓÕÕceÕÚÚejÚÝÝjmÝÞÞmnÞàànpàáápqáååquåææuv/\>//æççvwçêêwzêííz~íîî~€îïïññ‚„ñòò„…òõõ…ˆõ÷÷ˆŠ÷øøŠ‹øùù‹ŒùúúŒŽúüüŽ’üýý’“ý——>$—šš$(šœœ(*œŸŸ*,Ÿ££,1£¤¤12¤¨¨26¨©©67©««79«¬¬9:¬°°:?°±±?@±³³@B³´´BC´¶¶CE¶··EF·¸¸FG¸¹¹GH¹»»HJ»¼¼JK¼ÀÀKOÀÁÁOPÁÃÃPRÃËËRZËÎÎZ^ÎÏÏ^_ÏÐÐ_`ÐÒÒ`bÒÔÔbdÔÖÖdfÖ××fg×ØØghØÙÙhiÙÛÛikÛÜÜklÜßßloßââorâããrsãäästäèètxèééxyéëëy{ëìì{}ìðð}ƒðóóƒ†óôô†‡ôöö‡‰öûû‰‘û“‘||

Try it online!

I used shortstring.pl from Incident distro to generate the program, and then replaced all two-byte tokens with single-byte ones and removed separators.

NOTE, 23 bytes

.print/"Hello, World!"

Squire, 25 bytes

proclaim("Hello, World!")

Whilst I hath already posteth a "FizzBuzz" program, being the absolute jester I am, I forgoteth to proclaim "Hello, World!" first.

Being themed upon ye olde medieval times, one does not simply "print" in Squire. One must proclaim.

Lolwho.Cares, 35 bytes

>*2+00210v
^<0210<2`<
Hello, World!

Explanation:

The code is essentially a for loop; A counter increments, a character is then read from code. The program exits if this is 0 (end of line), or continues printing.

AEWNN, 75 bytes

[8+]cpar2[5+]cpa[7+]cpacpa+++cpa [8+]cpar2[15+]cpa+++cpar2[12+]cpar2++++cpa

Wiselang, 20 bytes

(an esoteric language of mine and BLA4KM4MBA)

eww "Hello, World!";

Lispy, 25 bytes

(println "Hello, World!")

This is an implementation of a Lisp invented by Daniel Holden in his book.

Knight, 16 bytes

O"Hello, World!"

Knight is a language made up by some people on my Discord back in April 2021, which is designed to be portable to various programming languages.

Explanation

O is shorthand for OUTPUT, which prints the first argument.

I think you can figure out the rest.

Subleq (8-bit), 25 bytes

12 -1 13
1 0 6
3 2 -1
11 11 0 
72 101 108 108 111 44 32 
87 111 114 108 100 33

Subleq Emulator

This is shorter than the other "Hello, World" samples I have seen online.

Explanation

 0: 12 -1 13                  'Output 12:; 2: is used as a countdown  
 3: 1 0 6                     '0: = 0: + 1; move to the next character
 6: 3 2 -1                    '2: = 2: - 1, if 2: <= 0 then exit 
 9: 11 11 0                   '11: = 0, goto 0
12: 72 101 108 108 111 44 32  '12: "Hello, " 
19: 87 111 114 108 100 33     '19: "World!"

EmojiCoder, 532 bytes

??????????
??????????
??????????
??????????
??????????
??????????
??????????
??????????
??????????
??????????
??????????
??????????
??????????

Try it online!

EmojiCoder is a funny language!

? represents binary 0 and ? binary 1. We construct the binary numbers of ASCII codepoints in Hello, World!, then pass it to ?, which is a modifier automatically casting the binary number to decimal base and get its ASCII character and ? pushes it to stack, Later stack is implicitly outputted.

():;+-#?!, 26 bytes

:H:e:l:l:o:,: :w:o:r:l:d:!

Try it online! (Node.js interpreter)

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:

yuno (abandoned), 2 bytes

」オ

No TIO link unfortunately, because I'm not good at setting this sort of stuff up and I don't want to accidentally make my server insecure (especially since I'm sharing it with a friend). You can clone the repository from the link in the header though. I promise I did not intentionally code malware. I can't guarantee nothing weird will happen though because I suck at coding, only that I don't have malicious intent.

This language is in its very early stages. It has very few things implemented right now, but it exists and by posting an answer and publicizing it maybe it'll force me to actually write it instead of giving up like half of my other language ideas so far, lol.

Explanation

Since オ is a string terminator, it's not mapped to anything in the normal string system, and therefore when represented as a single character, I special-cased it to Hello, World. 」 ends a string normally, but like in Jelly, when used without an open quote, it acts as a character literal, but in this case, it maps its codepage to latin characters.

A non-built-in solution would be 「Ｈｅｌｌｏ、　Ｗリョｌｄ！ (the 」 can be ommitted), based on how character mapping works.

The built-in can be written as ]o as well. The non-built-in can be written as [H_e_l_l_o, Wryo_l_d!.

Note: the non-built-in, despite looking like 14 characters (bytes in an SBCS), is actually 13 (you could use 「Ｈｅｌｌｏ、　Ｗｏｒｌｄ！ for 14). This is because リョ is a single token and, if you read the code in binary, is mapped to one byte. You can read more about this on the wiki, which also mentions where to find the exact codepage in the repository. There are some three-byte tokens like ッキョ. You can check how many bytes a program is using the c flag or format it into a CGCC submission using the C flag.

^{_{No, I don't have a good explanation for why I used katakana as my codepage. Yes, you can use hiragana as well. If you call me a weeb I will 11 you. That is all.}}

Snap!, 34 bytes

when gf clicked
say[Hello, World!]

Easiest program I've written in my life

Flurry -bnn, 710 bytes

(){}[(){}[(){}[(){}[(){}[(){}[(){}[(){}(<[{<({}){}>}{<({})({}){}>}][{<({})({}){}>}{<({}){}>}]>)((((<><<>()>[{<({}){}>}<{<({}){}>}{<({})({})({})({}){}>}>])[<><<>()>]{<({})({})({})({})({})({}){}>}))[<><<>()>]{<({})({}){}>})](<{<({})({})({}){}>}[<><<>()><{<({}){}>}{<({})({})({})({}){}>}>]>)]({<({})({})({})({}){}>}{<({}){}>})](<{<({})({}){}>}[<><<>()><{<({})({})({}){}>}{<({})({})({})({})({})({}){}>}>]>)](([{<({}){}>}<{<({}){}>}{<({})({})({})({}){}>}>][<><<>()>][<><<>()>[<{<({}){}>}{<({})({})({})({}){}>}>]])[<><<>()>]{<({})({}){}>})]([{<({}){}>}<{<({}){}>}{<({})({})({})({}){}>}>][<><<>()>][{<({})({}){}>}{<({}){}>}])]({<({}){}>}<{<({}){}>}{<({})({})({})({}){}>}>)](<><<>()>[{<({})({})({})({}){}>}{<({}){}>}])

Try it on the online Flurry interpreter!

1L_a, 3549 2532 bytes

 **********************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
 **   *   **    * **       *   *  *  *   **      * *   *    **  * *     *      **  *** *    *  *  *    **      **  *** **    *  *  * ***    **   *       *  **     *  ** *       **  *** *    *  *  *     **       *** *   *   *  *  * *    *  * *   *   *    *   **      *    ** ***   *       *  **  * *     *  **     *  ** *       * *    **  **   * *    *  **  * *  *      *  **  * *   *   *   **  **   *  * *      *  *  *    *
 *       * *  * *     * *    * *  **     **  *   *          *  *      * *  **       *  *  * *  **   **     **       *  *     ** **   *   *  *        *      *   **    *     ***       *  *  * *  **   * *    ***   **  *     * *  **   *       *         *      *     ***   **     *        *      *  *      * *      **    *     **   *   **     *      *       *   *** **    * *      *         *       *       *     ** *  **   **
    ***    *       *    **  *     *    *     **      *        *    **      *    *     **       *    *   *  *    *     **        *    ** **      ***  ** **    * *        *   *    *     **       *    *    *   **      **         *    **   *     * **   **   *    ** *     *   *      ***  ** **    *    **       ** *        *   **      *   *      *  **   *    *      **         *     * **   **   *      **  ** * **     *    *  *
***   **     *  *  *   **   *  *    *     *  *    *     **  *   **  *  **  ** *******    *  *    *  *****  ** * *****    **  *    *     ******  ***  *   *****  *     *  *   ** * *****    *  *    *  **  **   *    *       *  *    *      *****    ***      **    *  *  *  *********  ***  *   ****   **  *  ***  *  *     *  *   *    *  *********  *      *****     *      *  *** ****    ***       *****  **     *  *  *    *  ***
 **********************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************

Try it online! (heh, line wrapping makes it look wierd)

Automatically generated by this program, with some golfing (manual + golf.rb).

It is very hard to program in 1L_a, so I use generator. Generator creates cells, each cell prints one bit. It iterates through all possible cells with height 6 and no more than 5 inner asterisks to find a cell that prints the needed bit. Generator fails if height is less than 6 or max asterisk count is less than 5.

This is an ungolfed version with cells visible (13*8 = 104 cells):

  ****** ****** ****** ***** ****** ****** **** **** ****** ***** **** ****** ***** ***** ****** **** ****** ******* ***** ****** ***** **** ****** **** ****** ***** **** ****** ***** **** ******* **** ****** ***** **** ****** ***** ***** **** ***** ******* ***** ***** ****** ***** **** ****** **** ****** ****** ***** ****** **** ******* **** **** ****** ****** **** ******* ***** ****** ****** **** ******* ***** **** ****** ***** ***** **** **** ****** ******* ***** **** ******* ***** ***** ****** ***** ***** ***** ****** **** ****** **** ******* ***** ****** **** ***** **** ******* ***** ****** **** ****** **** ******* **** **** ****** *****
  **   * *   ** *    * * * * *         *      * *  * *  *      ** *        ** * *      ** *    * ** * * * ** *     * *         ** *  ** ** * *    * *  * *  *      ** *        ** *  ** ** * **    * *  * *  * * ***      * **   * *         * *  * **       *  * ** ** *         ** *  ** ** * *    * *  * *  *       ** *         ** ** * *   *      * *  * *  * * *    * *  * * *   * *   * *    * *   ** *        *      ** * ** **   * *         * *  * ** * * * ** *     * *  ** *       *  * ** ** *         ** * *      ** *  ** **   * ** * *    * *  * **  * * *  ** *         * *  ** *  * * *   * *   * *   ** *  * **   * *  * * *        * *  * *  *      **
  *         * * *  * * *        * * *    * ** * *  * **   * *  ** *  * *   ** *   * *          * *  * **         * * *   * **         * *  * *  * * *  * **   * **       * **         * *  * *     * ** * **   * *   * *  * *          * *        * *   * **    * *        ** **         * *  * *  * * *  * **   * * *      *** *   ** *  * *     * ** * *  * **   * *         * *           * *        *       * ***   * **       * *          * *        * *  * **         * * *        * **    * *        ** *   ** *   * **       ** *         * *         * *   *** * * * *    * ** * *        * *           * *         * *         * *     * ** * *  * **   * **   
     *** *    * *         ** *    * **  ** *       * *    * **       * **         * **  * *        ** *    * ***        ** *    * *       ** *         * *    * *   * *  * *    * *       ** *          * *    * ** ** *        ** **  * ** ** *      * * *          ** *   * *    * *       ** *         * *    * *    * *   * **        * **    * *       * *    * **   * *       * ** *   * **   * *    * ** * *     * *   * *        ** **  * ** ** *      ** *    * ***         * ** * *          ** *   * **         * *   * *         ** *  * **   * *      *        ** **   * *        * *       * ** *   * **   * *        ** *  * ** * ** *       * *    * *   *
* **   * **       *  * *  ** *   ** *   ** *  * *      *  * *   * *  * *    * **  * *   * ***  * *      ** * * *  ** *  ** ** *** ***** *      *  * *      *  * ***** *  * ** * * ***** *      **  * *      *       ** **** **  ** **  * *   * **** **  * *     * *  ** *   * ** * * ***** *      *  * *      *  * **  ** *   * *    * *         ** *  * *      *        ** **** *    ** **        ** *    * *  * *  *  * ***** **** **  ** **  * *   * **** *      ** * * *  ** **  * *  * *     * *  ** *   * *    * **  * ***** *** * **  ** *        ** **** *     * *         ** *  * *** * **** *    ** **         * **** **  ** *       *  * *  * *      *  * *****
  ****** ****** ****** ***** ****** ****** **** **** ****** ***** **** ****** ***** ***** ****** **** ****** ******* ***** ****** ***** **** ****** **** ****** ***** **** ****** ***** **** ******* **** ****** ***** **** ****** ***** ***** **** ***** ******* ***** ***** ****** ***** **** ****** **** ****** ****** ***** ****** **** ******* **** **** ****** ****** **** ******* ***** ****** ****** **** ******* ***** **** ****** ***** ***** **** **** ****** ******* ***** **** ******* ***** ***** ****** ***** ***** ***** ****** **** ****** **** ******* ***** ****** **** ***** **** ******* ***** ****** **** ****** **** ******* **** **** ****** *****

See also 1L_a answer to "Add a language to a polyglot" challenge.

Vyxal, 2 bytes

kH

Pushes the built-in string Hello, World!, with implicit output.

Try it Online!

Deadfish~, 1 byte

w

Try it online!

Kind of cheating really... but then I think there are some zero byte answers!

PPL, 26 bytes

printLine("Hello, World!")

PPL is a programming language made by me. This technically does not fall into the category of "standard loophole", because this was not made to be a golfing language (easily deduced from the program, which uses printLine, if it were a golfing language I would call the function p.)

The function printLine simply takes any expression and outputs it to STDOUT. Also, as a sidenote, PPL stands for Primitive Programming Language; it is not yet Turing-complete.

To run a PPL program, install the NPM package, then require it and call run with the sole argument being the program string (no documentation yet.)

Pinecone, 22 bytes

print: "Hello, World!"

Yggdrasil, 29 bytes

;H;e;l;l;o;,; ;W;o;r;l;d;!(")

Try it online!

Introducing Yggdrasil! This is a self-modify esolang based on binary trees. The program and it's memory model are both mapped to the same binary tree, then executed on that same tree. For example, this program is mapped to

                          ;
                         / 
                        ;   H
                       / 
                      ;   e
                     / 
                    ;   l
                   / 
                  ;   l
                 / 
                ;   o
               / 
              ;   ,
             / 
            ;   ␠
           / 
          ;   W
         / 
        ;   o
       / 
      ;   r
     / 
    ;   l
   / 
  ;   d
 / 
(   !

The ; command takes the next 2 tokens and forms a binary branch from them. All the other symbols in the tree are no-ops, they just set the value of that leaf to their Unicode code point. You'll note that ") are not nodes in the tree. Yggdrasil ignores any trailing symbols that don't fit into the tree.

Once we've established our memory tree, we then begin executing the code, character by character. ;H;e;l;l;o;,; ;W;o;r;l;d;! all have absolutely no effect, so the pointer remains at the program root (the first ;). We then find a "traversal", bounded by (...). This takes the code inside the brackets and runs it over each node in the tree that has arguments (i.e. is not a leaf). The code here is just " (output right node as character), so the program goes to each ; and outputs it's right node as a character.

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.

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)

• Official simulator
• One of unofficial online simulators

Branch, 42 bytes

72.101.108Z..111O.44.32.87.o.114.z.100.33.

Try it on the online Branch interpreter!

Explanation

Each number sets the value of the current node to that. . outputs as a character. N-Z set a numerical register and n-z set the value to the value of that register. I won't give a character-by-character analysis; this basically just loads each value and outputs it, using registers to save some bytes. It's not a particularly interesting solution.

10IPL, 67 bytes

00010000 00100000 00100000 00100000 00010000 00100000 00100000 00100000 00110000 00010010 00100010 00100010 00010010 00100010 00010010 00100010 00100010 01000001 00010000 00110000 00010100 00100100 00100100 00100100 00010100 01000010 00110000 00110000 00010000 00010000 00010000 00110000 00110010 00010110 00100110 00100110 00100110 00100110 01100011 00100110 00110110 00010100 00010100 00010100 00100100 01010000 00110100 00110000 00010000 00010000 00010000 00110000 00010100 00010100 00010100 00010100 00010100 01010100 00110100 00011010 00101010 00101010 00101010 01010101 00110100 00010110 00110110

Try it online!

Program:

inr r0
rtr r0
rtr r0
rtr r0
inr r0
rtr r0
rtr r0
rtr r0

prt r0

inr r1
rtr r1
rtr r1
inr r1
rtr r1
inr r1
rtr r1
rtr r1
xor r0, r1
inr r0

prt r0

inr r2
rtr r2
rtr r2
rtr r2
inr r2
xor r0, r2

prt r0
prt r0

inr r0
inr r0
inr r0

prt r0

prt r1

inr r3
rtr r3
rtr r3
rtr r3
rtr r3
xor r4, r3
rtr r3

prt r3

inr r2
inr r2
inr r2
rtr r2
xor r2, r0

prt r2

prt r0

inr r0
inr r0
inr r0

prt r0

inr r2
inr r2
inr r2
inr r2
inr r2
xor r2, r4

prt r2

inr r5
rtr r5
rtr r5
rtr r5
xor r2, r5

prt r2

inr r3
prt r3

What is 10IPL?

10IPL, short for 10 Instruction Programming Language, is a simple compiled language I made for use in a computer I'm building in Minecraft. I made an online interpreter for it (with a few extra features), since I think it's a neat language.

How does this work?

This program doesn't have anything fancy, it just uses three of 10IPL's instructions (Increment, Rotate, and XOR) to put numbers in registers, then prints them.

10IPL has four general purpose registers, r0 to r3. It also has r4 (or rp0) and r5 (or rp1), which are intended to hold pointers. I use these as normal registers to save having to waste bytes clearing the ones I've already used, since this program never needs to access memory.

Sandwich, 14 bytes

pHello, World!

Explanation: Sandwich is comprised of opcodes. The first letter of each line is the opcode, and the rest of the line is the arguments. This example has the opcode p, which means print. The rest of the line says Hello, World!, which are the arguments to the p opcode.

Duocentehexaquinquagesimal, 28 bytes

1Ƶ¸ñ=öu¯2–sε`;ÈùˆζT¿āΔIÈ3Wÿ»

Try it online!

Grok, 23 bytes

`jiHello, World!
}lYW
q

Non-terminating version, 18 bytes

iHello, World!`lwh

Python 3 + lkjqwhe, 8 bytes

import a

Well, I beat It's-a-fake-one-Daniel. ¯_(ツ)_/¯

Golunar, 66 bytes

142209095870573693396245504627320468349603549841832242891887476756

Kotlin, 33 bytes

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

This is probably the shortest you can go.

Arturo, 20 bytes

print"Hello, World!"

Python3, 9 Bytes

import qz

Try online

It's kind of cheating because it's using an external package but I don't think there is another way to pass the boring:

print("Hello, World!")

Rust, 36 bytes

Extremely basic, and no explanation needed, but here:

fn main(){println!("Hello, World!")}

If, for some reason, anyone would like to try it, you can here

BRASCA, 14 bytes

Another simple Hello, World program.

`Hello, World!

Explanation

`                  - Push everything from here to the next backtick (or EOF) to the stack
 Hello, World!     - The text, duh :^)
<implicit output>  - Output the contents of the stack reversed

Language Link

Github Repo

Pxem, 15 bytes (filename) + 0 byte (contents) = 15 bytes

Filename

Hello, World!.p

Content

(none)

Description of program

The program above should output the phrase without LF. If you'd like LF, here is an alternative filename (19 bytes);

ak.-Hello, World!.p

Description of language

The main feature of this programming language to recognize filename as main routine of the program; content of the file is subroutine.

So far there are two major implementations:

• Designer's original C++ implementation --- Distributed as pxemi.7z.
• wktk's Ruby implementation

Length, 1071 bytes

Somebody once told me the
world is
gonna roll m
e. I ain't the sharpest t
o
ol in the
shed. She was lookin
kinda dumb w
ith her finger a
nd her thumb in the shape
of an L on her forehead. Well
the years
start coming
and they don't s
top coming... fed to the
rules a
nd I hit t
he ground ru
nning. Didnt
make sense not t
o live for fun.
Your brain gets smart, bu
t y
our head g
ets dumb. So muc
h to do, so much to see,
so what's w
rong with taking the back
stre
ets? You never know
if you don't
go. You neve
r shine if you d
on't glow. Hey now, your'
e an all sta
r, get your
game on, go play
. Hey now, y
our'e a ro
ckstar, get the show on,
g
et paid. Al
l that glitt
ers is gold. Onl
y shooting stars break th
e mould. It's a cool pla
ce and the
y say it get
s colder. You're
bundled up now, wait till
you
get older.
But the medi
a men beg to dif
fer, judging by the hole
in the
satellite p
icture. The
ice we skate is
getting pretty thin. The
water's
getting war
m, so you might
as well swim. My world's
on fire, how about yours? Thats t
he way I like it

There's an interpreter, but there's no permalink

Length is a newly created esolang by esolang.org user Nailuj29, so I thought I'd give it a go and write a HW program hopefully shorter than the example one. Spoiler: this is 42 bytes shorter. The commands are decoded based on the number of characters in each line.

And yes, I did use the lyrics to All Star by Smash Mouth.

Explained

Assembly-like representation

push 8
dup
push 1
add
mul
dup
outa
push 29
add
dup
outa
push 7
add
dup
dup
outa
outa
push 3
add
outa
push 11
push 4
mul
dup
dup
outa
push 12
sub
outa
dup
add
push 1
sub
dup
outa
push 24
add
dup
outa
push 3
add
dup
outa
push 6
sub
dup
outa
push 8
sub
outa
push 33
outa

debug logs

1
push
----------
[8]
3
dup
----------
[8,8]
4
push
----------
[8,8,1]
6
add
----------
[8,9]
7
mul
----------
[72]
8
dup
----------
[72,72]
9
outa:::::::::
H----------
[72]
10
push
----------
[72,29]
12
add
----------
[101]
13
dup
----------
[101,101]
14
outa:::::::::
e----------
[101]
15
push
----------
[101,7]
17
add
----------
[108]
18
dup
----------
[108,108]
19
dup
----------
[108,108,108]
20
outa:::::::::
l----------
[108,108]
21
outa:::::::::
l----------
[108]
22
push
----------
[108,3]
24
add
----------
[111]
25
outa:::::::::
o----------
[]
26
push
----------
[11]
28
push
----------
[11,4]
30
mul
----------
[44]
31
dup
----------
[44,44]
32
dup
----------
[44,44,44]
33
outa:::::::::
,----------
[44,44]
34
push
----------
[44,44,12]
36
sub
----------
[44,32]
37
outa:::::::::
 ----------
[44]
38
dup
----------
[44,44]
39
add
----------
[88]
40
push
----------
[88,1]
42
sub
----------
[87]
43
dup
----------
[87,87]
44
outa:::::::::
W----------
[87]
45
push
----------
[87,24]
47
add
----------
[111]
48
dup
----------
[111,111]
49
outa:::::::::
o----------
[111]
50
push
----------
[111,3]
52
add
----------
[114]
53
dup
----------
[114,114]
54
outa:::::::::
r----------
[114]
55
push
----------
[114,6]
57
sub
----------
[108]
58
dup
----------
[108,108]
59
outa:::::::::
l----------
[108]
60
push
----------
[108,8]
62
sub
----------
[100]
63
outa:::::::::
d----------
[]
64
push
----------
[33]
66
outa:::::::::
!----------
[]

kavod, 47 bytes

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

Try it online!

!@#$%^&*()_+, 17 bytes

 ^dlroW ,olleH(@)

Try it online!

Scala 3, 34 bytes

@main
def m=print("Hello, World!")

Thought Dotty deserved its own answer.

Try it in Scastie

Fugue, 276 bytes

00000000: 4d54 6864 0000 0006 0001 0002 0001 4d54  MThd..........MT
00000010: 726b 0000 001b 0090 4040 0190 3c40 0090  rk......@@..<@..
00000020: 4640 1b90 4440 0390 4240 0190 4740 00ff  [email protected]@[email protected]@..
00000030: 2f4d 5472 6b00 0000 db00 905c 4001 905d  /MTrk......@..]
00000040: 4001 9059 4000 905c 4001 9058 4000 904e  @..Y@[email protected]@..N
00000050: 4001 904f 4001 904b 4000 9049 4001 904a  @[email protected]@[email protected]
00000060: 4001 9046 4000 904a 4001 904b 4001 9047  @[email protected]@[email protected]
00000070: 4000 9048 4001 9049 4001 904a 4001 9046  @[email protected]@[email protected]
00000080: 4000 904d 4001 904e 4001 904a 4000 904c  @[email protected]@[email protected]
00000090: 4001 9048 4000 9048 4001 9044 4000 9048  @[email protected]@[email protected]
000000a0: 4001 9044 4000 9045 4001 9046 4001 9042  @[email protected]@[email protected]
000000b0: 4000 9040 4001 9041 4001 903d 4000 903b  @..@@..A@..=@..;
000000c0: 4001 903c 4001 9038 4000 902f 4001 9030  @..<@..8@../@..0
000000d0: 4001 902c 4000 9027 4001 9023 4000 902a  @..,@..'@..#@..*
000000e0: 4001 9031 4002 9032 4001 9037 4003 9038  @[email protected]@[email protected]
000000f0: 4001 9039 4001 903a 4001 903f 4001 9044  @..9@..:@[email protected]
00000100: 4001 9049 4001 904e 4001 9056 4001 904f  @[email protected]@[email protected]
00000110: 4000 ff2f                                @../

This answer uses the same process as Sp3000's Prelude answer. However, since Fugue can push any integer from -10 to 10, I use the upper voice to store the constant 10 (since copying a value takes one fewer instruction than pushing a new one) and then convert from base 11. The compiler is rather old and can be tricky to use; my usual process (on x86-64 Linux) is to use the commands:

gcc -Dstricmp=strcasecmp -Wno-format -o fugue_x86 fugue_x86.c

xxd -r hello.bin > hello.midi
./fugue_x86 hello.midi /coffc
gcc -D__cdecl= -Dfugue=_fugue -m32 -o hello hello.obj hello_wrp.c

Note that this program is not a valid MIDI file due to the missing length fields after the 2F meta-events. I didn't optimize it at all for musicality, but if you still want to listen to it, here is an equivalent MIDI file:

00000000: 4d54 6864 0000 0006 0001 0002 0001 4d54  MThd..........MT
00000010: 726b 0000 001c 0090 4040 0190 3c40 0090  rk......@@..<@..
00000020: 4640 1b90 4440 0390 4240 0190 4740 00ff  [email protected]@[email protected]@..
00000030: 2f00 4d54 726b 0000 00dc 0090 5c40 0190  /.MTrk......@..
00000040: 5d40 0190 5940 0090 5c40 0190 5840 0090  ]@..Y@[email protected]@..
00000050: 4e40 0190 4f40 0190 4b40 0090 4940 0190  [email protected]@[email protected]@..
00000060: 4a40 0190 4640 0090 4a40 0190 4b40 0190  [email protected]@[email protected]@..
00000070: 4740 0090 4840 0190 4940 0190 4a40 0190  [email protected]@[email protected]@..
00000080: 4640 0090 4d40 0190 4e40 0190 4a40 0090  [email protected]@[email protected]@..
00000090: 4c40 0190 4840 0090 4840 0190 4440 0090  [email protected]@[email protected]@..
000000a0: 4840 0190 4440 0090 4540 0190 4640 0190  [email protected]@[email protected]@..
000000b0: 4240 0090 4040 0190 4140 0190 3d40 0090  B@..@@..A@..=@..
000000c0: 3b40 0190 3c40 0190 3840 0090 2f40 0190  ;@..<@..8@../@..
000000d0: 3040 0190 2c40 0090 2740 0190 2340 0090  0@..,@..'@..#@..
000000e0: 2a40 0190 3140 0290 3240 0190 3740 0390  *@[email protected]@..7@..
000000f0: 3840 0190 3940 0190 3a40 0190 3f40 0190  [email protected]@..:@..?@..
00000100: 4440 0190 4940 0190 4e40 0190 5640 0190  [email protected]@[email protected]@..
00000110: 4f40 00ff 2f00                           O@../.

Source Engine Console, 18 bytes

echo Hello, World!

You can't try it online unless Valve ports Half-Life 2 to WASM or something.

This script is pretty basic. It's perfectly valid to echo like this without quotes in the Source Engine.

The Source Engine is a game engine developed by Valve Software, and used in all their games after 2004 (until DOTA 2 in 2015). It provides basic scripting through console commands. You can test this by opening the developer console (enable in settings and press the ` key) and pasting the line.

Tested in Team Fortress 2, CS:GO and Source SDK Base 2013 (Multiplayer).

By inspecting some leftover E3 demo scripts in Half-Life 2, it's revealed there was a rem command which could be a shorter 17 bytes, but this is no longer present in the engine (and I assume that a rem doesn't count because it doesn't print anything). I've yet to test if it exists in Source 2004, but can confirm it's missing in Source 2013.

Technically, the console isn't STDOUT, however the only way to really output to STDOUT is by using the SDK to make a game of my own (obviously compiling to a very large size).

Shu, 931 bytes

IncreaseBy100 DecreaseBy10 DecreaseBy10 DecreaseBy10 IncreaseBy1 IncreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 DecreaseBy1 DecreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 DecreaseBy1 DecreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 IncreaseBy1 PrintChar Clear IncreaseBy10 IncreaseBy10 IncreaseBy10 IncreaseBy10 IncreaseBy1 IncreaseBy1 IncreaseBy1 IncreaseBy1 PrintChar Clear IncreaseBy10 IncreaseBy10 IncreaseBy10 IncreaseBy1 IncreaseBy1 PrintChar Clear IncreaseBy100 DecreaseBy10 DecreaseBy1 DecreaseBy1 DecreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 IncreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 IncreaseBy1 IncreaseBy1 IncreaseBy1 IncreaseBy1 PrintChar Clear IncreaseBy100 IncreaseBy10 DecreaseBy1 DecreaseBy1 PrintChar Clear IncreaseBy100 PrintChar Clear IncreaseBy10 IncreaseBy10 IncreaseBy10 IncreaseBy1 IncreaseBy1 IncreaseBy1 PrintChar Clear

Befalse, 43 30 bytes

"!dlroW ,o"
/?$!"Hell"/
. /

If this gets down to 1 line, it would be much shorter without all the spaces on the second line. I’ll golf this further.

Thanks to Jo King♦ for golfing this further. I think it can be golfed even more now.

Taktentus, 22 bytes

@WY _= "Hello, World!"

I believe this is the shortest it can get. I would like to be proven wrong.

Bound, 48 bytes

72:c29:+c7+cc3+44:32:87:c24:+c3+c6-c8-33:13:({ds

Explanation:
Technically, Bound prints out "Hello, World!" with a blank program. But that's boring.
So instead, the program above basically creates the relevant ASCII numbers, then loops through them, converting them into chars and writing them. Someone better at math than me could probably golf this better, but I did my best.

Try it online!

Rutger, 23 bytes

Print["Hello, World!"];

Try it online!

An old language of mine, and fairly basic, but included for comprehension.

Mornington Crescent, 3328 3271 bytes

Take Northern Line to Leicester Square
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Bank
Take District Line to Hammersmith
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Bow Road
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Parsons Green
Take District Line to Gunnersbury
Take District Line to Paddington
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Gunnersbury
Take District Line to Barking
Take District Line to Acton Town
Take Piccadilly Line to Holloway Road
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Elm Park
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminal 5
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Plaistow
Take District Line to Hammersmith
Take District Line to Gunnersbury
Take District Line to Mile End
Take District Line to Elm Park
Take District Line to Mile End
Take District Line to Paddington
Take Circle Line to Paddington
Take Hammersmith & City Line to Barking
Take Hammersmith & City Line to Paddington
Take Circle Line to Paddington
Take Bakerloo Line to Piccadilly Circus
Take Bakerloo Line to Piccadilly Circus
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Westminster
Take District Line to Gunnersbury
Take District Line to Bow Road
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Aldgate
Take Metropolitan Line to Chorleywood
Take Metropolitan Line to Aldgate
Take Circle Line to Aldgate
Take Circle Line to Bank
Take District Line to Bow Road
Take District Line to Hammersmith
Take District Line to Gunnersbury
Take District Line to Plaistow
Take District Line to Gunnersbury
Take District Line to Mile End
Take Hammersmith & City Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take District Line to Mile End
Take District Line to Bow Road
Take District Line to Mile End
Take Hammersmith & City Line to Paddington
Take Circle Line to Paddington
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Paddington
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Try it online!

-57 bytes by using shorter lines and transfer stations

Short explanation: I extract following strings:

Heathrow Terminals 1, 2, 3 (also extracting the numbers for some operations)
--                     --

Holloway Road
  ---

Westminster
-

Chorleywood
  ---     -

The strings are cut in pieces, using the left and right substring functions of Gunnersbury and Mile End with the integers of "Heathrow Terminals 1, 2, 3" and "Heathrow Terminal 5" (which can be extracted using Parsons Green).

Then I concatenate them in Paddington and append a "!" by using the char code of (space)+1.

Source:

// ### Milestone: Extract "He", 1, 2, ", " from "Heathrow Terminals 1, 2, 3"

// Get "Heathrow Terminals 1, 2, 3"
Take Northern Line to Leicester Square
Take Piccadilly Line to Heathrow Terminals 1, 2, 3

// Copy that string
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Bank // Hammersmith = "Heathrow Terminals 1, 2, 3"

// Prepare for left substring
Take District Line to Hammersmith
Take District Line to Gunnersbury // Gunnersbury = "Heathrow Terminals 1, 2, 3"

// Extract 1 from "Heathrow Terminals 1, 2, 3"
Take District Line to Hammersmith
Take District Line to Parsons Green // Acc = 1, Parsons Green = ", 2, 3"

// Copy and store it somewhere (Parsons Green only returns its stored value if it gets a number)
Take District Line to Bank // Hammersmith = 1
Take District Line to Hammersmith
Take District Line to Bow Road // Bow Road = 1

// Store it in Upminster for later calculations
Take District Line to Hammersmith
Take District Line to Upminster

// Store 2
Take District Line to Hammersmith
Take District Line to Parsons Green // Acc = ", 2, 3"
Take District Line to Parsons Green // Acc = 2, Parsons Green = ", 3"

// Get "He"
Take District Line to Gunnersbury

// Store it in Paddington for concatenation
Take District Line to Paddington // Paddington = "He"

// Extract ", " from ", 3"
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Gunnersbury // 2 was still stored in Gunnersbury

// Store it somewhere
Take District Line to Barking // Barking = ", "

// ### Milestone: Extract "llo" from "Holloway Road"

// Get "Holloway Road"
Take District Line to Acton Town
Take Piccadilly Line to Holloway Road

// Prepare for left substring
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Gunnersbury // Gunnersbury = "Holloway Road"

// Store 3
Take District Line to Hammersmith
Take District Line to Parsons Green // Acc = 3
Take District Line to Elm Park // Elm Park = 3

// Get 5 from "Heathrow Terminal 5"
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminal 5
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green // Acc = 5

// Copy and Store it somewhere
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Plaistow // Plaistow = 5

// Get "Hollo" from "Holloway Road"
Take District Line to Hammersmith
Take District Line to Gunnersbury // Gunnersbury = 5

// Prepare for right substring
Take District Line to Mile End // Mile End = "Hollo"

// Get "llo" from "Hollo"
Take District Line to Elm Park
Take District Line to Mile End

// Append it to "He"
Take District Line to Paddington
Take Circle Line to Paddington

// Append ", "
Take Hammersmith & City Line to Barking
Take Hammersmith & City Line to Paddington
Take Circle Line to Paddington // Paddington = "Hello, ", Acc = ", Hello, "

// ### Milestone: Get "!" by adding 1 to char value of " "
// Reverse acc
Take Bakerloo Line to Piccadilly Circus
Take Bakerloo Line to Piccadilly Circus
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Turnpike Lane

// Get ASCII value of " "
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross // Acc = 32

// Add 1
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Upminster // 1 was stored in Upminster earlier
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross // Charing Cross = 33

// ### Milestone: Append "W" from "Westminster"
// Get "Westminster"
Take Northern Line to Bank
Take Circle Line to Westminster

// Get "W"
Take District Line to Gunnersbury // Gunnersbury = "Westminster"
Take District Line to Bow Road
Take District Line to Bank
Take District Line to Hammersmith
Take District Line to Gunnersbury

// Append it to "Hello, "
Take District Line to Paddington
Take Circle Line to Paddington

// ### Milestone: Append "orl" and "d" from "Chorleywood"
// Get "Chorleywood"
Take Circle Line to Aldgate
Take Metropolitan Line to Chorleywood

// Save it for copy
Take Metropolitan Line to Aldgate
Take Circle Line to Aldgate
Take Circle Line to Bank

// Bank had 1 in it, so save it for later
Take District Line to Bow Road

// prepare left substring
Take District Line to Hammersmith
Take District Line to Gunnersbury

// get "Chorl"
Take District Line to Plaistow
Take District Line to Gunnersbury

// get "orl"
Take District Line to Mile End // 3 is still stored in Mile End

// append it to "Hello, W"
Take Hammersmith & City Line to Paddington
Take Circle Line to Paddington

// get "d"
Take Circle Line to Hammersmith
Take District Line to Mile End
Take District Line to Bow Road
Take District Line to Mile End

// append it to "Hello, Worl"
Take Hammersmith & City Line to Paddington
Take Circle Line to Paddington

// get "!" and append it to "Hello, World"
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Paddington

// go home
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Desmos, 41 bytes

[40,69,76,76,79,12,0,55,79,82,76,68,1]+32

View it online

Desmos doesn't support strings, so we return an array of integers representing the codepoints instead. There's no good way to view an entire array at once in Desmos, so instead you can check it by taking the output by wrapping it in parenthesis or storing it in a variable, then accessing (1-indexed) array items like a[1] or ([40,...,1]+32)[1]. Or just add 32 to the numbers in the array to check that they're right.

MathGolf, 14 bytes

'H╕○ô╣·'W╕7ÿ'!

Try it online.

Or alternatively just the plain and simply:

"Hello, World!

Try it online.

Explanation:

'H              '# Push "H"
  ╕○ô            # Push compressed "ello"
     ╣·          # Push compressed ", "
       'W       '# Push "W"
         ╕7ÿ     # Push compressed "orld"
            '!  '# Push "!"
                 # (implicitly output the entire stack joined together to STDOUT)

"Hello, World!  "# Push "Hello, World!"
                 # (implicitly output the entire stack joined together to STDOUT)

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!

Vyxal, 8 bytes

`ƈṡ, ƛ€!

Try it Online!

Simply the compressed string Hello, World!

Alternatively,

Vyxal, 2 bytes

kH

Pushes the constant Hello, World!

MAWP 2.0, 16 bytes

"Hello, World!":

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

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

CSS, 62 bytes:

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

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

Arn, 6 bytes

'Mh└a└

Explanation

Unpacked:

'yt, bs!

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

Integral, 13 bytes

÷Hello, W╗ld!

Try it!

Sadly, Integral cannot yet compress capital letters, so it could not do much compression.

÷ means start compressed string.

Ignoring punctuation and capitalization yields

Integral, 9 bytes

÷▓llo═╗ld

Try it!

See also: Showcase

FerNANDo, 109 bytes

7 7
3
5 5
6 5
4 3 3
0 5 3 0 7 3 0 0
0 5 7 0 0 5 0 4
0 6 5 2 4 6 2 3
0 6 6 0 7 7 2 3
0 6 6 2 5 4 7 4
2 2
3 5
3

Try it online!

riscv32 and riscv64 (little endian) machine language for Linux, 38 bytes

0x00:       4505                    li      a0,1  ; Set fd=1
0x02:       012005ef                jal     a1,14 ; jmp and put ret addr in a1
0x06:       6c6c6548                              ; "Hello, World!"
0x0a:       57202c6f
0x0e:       646c726f
0x12:       0021
0x14:       4635                    li      a2,13 ; length of string
0x16:       04000893                li      a7,64 ; select write() syscall
0x1a:       00000073                ecall         ; call write()
0x1e:       05d00893                li      a7,93 ; select exit() syscall
0x22:       00000073                ecall         ' call exit()

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

const char main[]="x05x45xefx05x20x01Hello, World!x35x46x93x08x00x04x73x93x08xd0x05x73";

Jsonnet (with -S), 15 characters

"Hello, World!"

(Where -S stands for --string, meaning “Expect a string, manifest as plain text”.)

Sample run:

bash-5.0$ jsonnet -Se '"Hello, World!"'
Hello, World!

OpenRISC or1k (big endian) machine language on Linux, 48 45 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 18     l.addi r4,r9,24   ; 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 00 00 01     l.sys 0x1         ; call exit()
0x20:        48 65 6c 6c                       ; "Hello, World!"
0x24:        6f 2c 20 57
0x28:        6f 72 6c 64
0x2c:        21

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

const main[]={0x04000002,0x9c600001,0x9c890018,0x9ca0000d,
              0x9d600040,0x20000001,0x9d60005d,0x20000001,
              'Hell','o, W','orld','!'};

Cubically, 48 46 bytes

The previous best answer seems to have been 78 bytes long. I consider this a victory.

+35@⊕5@⊕1L@@|4U@-53@-0@R+43@+4@B'⊕3@-0@F-0@:5@

Found via computer search within a restricted subset of Cubically. Corresponding Most efficient cubifier answer by me.

Try it online!

evil, 70 bytes

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Try it online!

Deadfish~, 1 byte

w

Try it online!

Brainetry, 651 bytes

This is a boring golf of the program that comes after this one.

a b c d
a b c d e f g h
a b c d e
a b c d e
a b
a b c d e
a b c d e f g h
a b
a b
a b c d
a b
a b c d e
a b c d e
a b c d e
a b c d e
a b c d e
a b c
a b c
a b c d e f g h i
a b c
a b c d e
a b c d e
a b c
a b c d e
a b c d e
a b c d e
a b c d e f g h i
a b
a b c d e
a b c d e f g
a b
a b
a b
a b c d
a b c d e f g
a b
a b
a b c d e f g
a b c d e f g
a b c d
a b c d
a b c d
a b c d e f g h
a b c d e f g
a b
a b c d e f g h i
a b c
a b c
a b c
a b c
a b c d e f g
a b c d
a b c d
a b c d
a b c d e f g
a b c d e
a b c d e
a b c d e
a b c d e
a b c d e
a b c d e
a b c d e f g
a b c
a b c
a b c d e
a b c d e f g
a b
a b
a b
a b
a b c d
a b c d e f g

Ungolfed but far more interesting to read:

This is a "short"
brainetry program that outputs, to stdout, the message
"Hello, World!" as per the
programming world standard. This standard
dictates that
a user that is trying
a language for the first time should write
as its
first program
this "Hello, World!" program.
Of course,
this becomes a repetitive task,
this becomes a repetitive task,
this becomes a repetitive task,
this becomes a repetitive task,
this becomes a repetitive task,
but that shouldn't
hinder you from
tackling this awesome challenge in the Brainetry programming language.
Me, myself and
I have found this language
to be quite amusing if
used to write
self-referential programs like this one.
Self-referential objects are objects that
I, personally, really enjoy. This
might be because I am just a weird person.
Or not!
Who knows? Certainly not me.
Dear reader, please rest assured that we
are ALMOST
at the
MIDDLE of
this self referential program.
Also, please refraing from adding the hyphen
between self
and referential
in the line above, as it is
NOT a typo, it is missing purposefully.
A very important skill
needed to write Brainetry
programs is one's imagination.
This is because each instruction needs one line
of Brainetry source code on its own.
Sounds easy?
I can assure you, it definitely is not easy.
I'm growing tired,
I'm growing unimaginative,
I'm growing old,
I'm writing code.
Oh boy, I wish that would've rhymed!
Even though I can't
really rhyme in English
because I am unskilled,
I can tell you that this is
exhibiting signs of schizophrenia, right?
At this point I am
pretty much talking to myself,
and no one is listening,
right? No one is listening,
right? I definitely hope not.
Now on to some decent source code,
this program works
by harnessing the
well known power of modular
arithmetic, a really nice thing mathematics has
bestowed upon
us, mortals.
This is,
for real,
a really awesome gift
from the mathematicians of yor to us.

Builds on top of this awesome brainfuck answer.

MAWP, 86 62 bytes

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

Try it!

C64 BASIC, 16 characters, 20 bytes

If HELLO, WORLD! is fine.

0?"HELLO, WORLD"

Tetr4phobi4, 454 bytes

4OUR
fuor
fuor
4OUR
4OUR
4444
FO44
4OUR
4OUR
4OUR
4OUR
4OUR
fuor
4OUR
4OUR
4OUR
4OUR
4OUR
fuor
4OUR
four
4444
fuor
4OUR
4OUR
4OUR
4OUR
4OUR
4OUR
4OUR
four
4444
4444
fuor
4OUR
4OUR
4OUR
four
4444
FO44
4OUR
4OUR
4OUR
fuor
FOU4
4444
ffff
4OUR
4OUR
fuor
4444
FO44
4OUR
4OUR
4OUR
4OUR
4OUR
fuor
4OUR
4OUR
fuor
FOU4
four
4444
4OUR
4OUR
4OUR
4OUR
4OUR
4OUR
4444
4OUR
fuor
FOU4
four
4444
FOU4
FOU4
fuor
4OUR
4OUR
four
4444
FOU4
FOU4
4444
44UR
fuor
4OUR
four
4444

Ungolfed Code:

{44} H -> 72
4OUR$$$$fuor$$$$fuor$$$$4OUR$$$$4OUR      {44} CELL[1] + 4 * 4 * 4 + 4 + 4
4444                                      {44} Print CELL[1]
FO44                                      {44} Next Cell

{44} e -> 101
4OUR$$$$4OUR$$$$4OUR$$$$4OUR$$$$4OUR      {44} CELL[2] + 4 + 4 + 4 + 4 + 4
fuor$$$$4OUR$$$$4OUR$$$$4OUR$$$$4OUR      {44} CELL[2] * 4 + 4 + 4 + 4 + 4
4OUR$$$$fuor$$$$4OUR$$$$four              {44} CELL[2] + 4 * 4 + 4 / 4
4444                                      {44} Print CELL[2]

{44} l -> 108
fuor$$$$4OUR$$$$4OUR$$$$4OUR$$$$4OUR      {44} CELL[2] * 4 + 4 + 4 + 4 + 4
4OUR$$$$4OUR$$$$4OUR$$$$four              {44} CELL[2] + 4 + 4 + 4 / 4
4444$$$$4444                              {44} Print CELL[2] twice

{44} o -> 111
fuor$$$$4OUR$$$$4OUR$$$$4OUR$$$$four      {44} CELL[2] * 4 + 4 + 4 + 4 / 4
4444                                      {44} Print CELL[2]
FO44                                      {44} Next Cell

{44} , -> 44
4OUR$$$$4OUR$$$$4OUR$$$$fuor$$$$FOU4      {44} CELL[3] + 4 + 4 + 4 * 4 - 4
4444                                      {44} Print CELL[3]

{44} Whitespace -> 32
ffff                                      {44} Reset CELL[3]
4OUR$$$$4OUR$$$$fuor                      {44} CELL[3] + 4 + 4 * 4
4444                                      {44} Print CELL[3]
FO44                                      {44} Next Cell

{44} W -> 87
4OUR$$$$4OUR$$$$4OUR$$$$4OUR$$$$4OUR      {44} CELL[4] + 4 + 4 + 4 + 4 + 4
fuor$$$$4OUR$$$$4OUR$$$$fuor$$$$FOU4      {44} CELL[4] * 4 + 4 + 4 * 4 - 4
four                                      {44} CELL[4] / 4
4444                                      {44} Print CELL[4]

{44} o -> 111
4OUR$$$$4OUR$$$$4OUR$$$$4OUR$$$$4OUR      {44} CELL[4] + 4 + 4 + 4 + 4 + 4
4OUR                                      {44} CELL[4] + 4
4444                                      {44} Print CELL[4]

{44} r -> 114
4OUR$$$$fuor$$$$FOU4$$$$four              {44} CELL[4] + 4 * 4 - 4 / 4
4444                                      {44} Print CELL[4]

{44} l -> 108
FOU4$$$$FOU4$$$$fuor$$$$4OUR$$$$4OUR      {44} CELL[4] - 4 - 4 * 4 + 4 + 4
four                                      {44} CELL[4] / 4
4444                                      {44} Print CELL[4]

{44} d -> 100
FOU4$$$$FOU4                              {44} CELL[4] - 4 - 4
4444                                      {44} Print CELL[4]
44UR                                      {44} Prev Cell

{44} ! -> 33
fuor$$$$4OUR$$$$four                      {44} CELL[3] * 4 + 4 / 4
4444                                      {44} Print CELL[3]

Try it online!

vJASS (Warcraft 3), 78 58 bytes

Using //! import zinc "<code_path>" command to exclude //! zinc and //! endzinc.

library a{function onInit(){BJDebugMsg("Hello, World!");}}

Explanation:

• BJDebugMsg() prints the text on your in-game screen.

evil, 62 58 bytes

^{no I haven't read through the over 500 other answers to make sure I'm adding something new}
Found via computer search within a restricted subset of evil.

aeeaeayekeulaaaweevuewpuuuwwlweaaewguwuewpaaawaaawpweeawgw

Uses the instructions:

a increment the accumulator
u decrement the accumulator
z accumulator = 0
e weave operator (bitwise 01234567 to 20416375 on the accumulator)
w write character
k set the first pental cell to the accumulator
g set the accumulator to the first pental cell
v swap the accumulator and the first pental cell
y set the first wheel cell to the accumulator
l set the accumulator to the first wheel cell
p swap the accumulator and the first wheel cell

The pental is a thingy that stores 5 bytes and can be rotated; I don't rotate it though. The wheel is a circular list that starts at 1 element; I don't add/remove to/from it.

Try it online!

><>, 25 bytes

!v"!dlroW ,olleH"!
o>l?!;

Try it online!

My second answer in this language so far, started learning only today, thought this would be a good starting point

Cood, 378 bytes

I want 72 of this
Im very hungry
More 29 of this
Im very hungry
More 7 of this
Im very hungry
Im very hungry
More 3 of this
Im very hungry
Less 67 of this
Im very hungry
Less 12 of this
Im very hungry
More 55 of this
Im very hungry
More 24 of this
Im very hungry
More 3 of this
Im very hungry
Less 6 of this
Im very hungry
Less 8 of this
Im very hungry
Less 67 of this
Im hungry

Try it online!

KRC, 17 bytes

This defines a function returning the string "Hello, World!". No trailing newline because it's shorter. (I've made a repl.it for KRC.)

f="Hello, World!"

Demo:

$ ./krc demo/hello
Kent Recursive Calculator 1.0
revised 2016.03.31
/h for help
krc> f!
Hello, World!krc>

Roj, 18 bytes

I love this simple BASIC dialect ...

out"Hello, World!"

Explanation

out                $ Output $
   "Hello, World!" $ the string "Hello, World" $

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.

tq, 15 bytes

"Hello, World!"

Pretty much just defines a list with the only item as the string "Hello, World!".

Symbolic Raku, 34 bytes

$_='(%,,/ @)/),$!'~^'`@@@@`~@[@@'

Try it online!

My newest language, though it's not too original. This is inspired by FlipTack's Symbolic Python, which bans the use of alphanumeric characters, but otherwise executes as Python code. In this case, I've used the language Raku (previously known as Perl 6), which takes input through the $_ and similarly outputs it's contents at the end of execution. Symbolic Raku does not have an extra eval operator like Symbolic Python, but it is still Turing complete through the other operators and symbols that Raku provides.

In this case, we use the string xor operator (~^), which takes two strings to produce the string Hello, World!, which is obviously banned from hardcoding because it contains letters. A shortcut for producing these strings is included in the reference implementation through the -g=string flag. Currently, this is not yet on TIO, so the link goes to the Raku language instead.

Spice, 20 bytes

@OUT "Hello, World!"

Explanation

Should be pretty straight forward what's happening, but we use some undefined behaviour to shave off 2 bytes (interpreter version 1.1.0.0, which is current at time of submission). The program should read:

;@
OUT "Hello, World!";

as per the spec, but we drop the ; as we only have one instruction and don't need to define an instruction separator, and so also have no trailing ; at the end.

Ral, 103 bytes

What better way to introduce a new language than by posting the 768th "Hello, World!"?

Hand-made code, can probably be improved a lot.

11+:+:+:0=1+:+:+::+:.+0*/-::1+.0*+:::..1+1+1+::.0*:+:+:11+1+:+:++..10*1+1+1+:+:+:+-..1+1+1+...0*:+:+1+.

Try it online!

Intcode, 83 72 70 bytes

204,8,109,1,1205,8,0,99,72,101,108,108,111,44,32,87,111,114,108,100,33

Try it online!

Old 83 byte version:

1106,0,17,72,101,108,108,111,44,32,87,111,114,108,100,33,0,204,3,109,1,1205,3,17,99

W d, 12 10 bytes (SBCS)

.s*♪╧T≈╪√ù

Explanation

This program is a compressed program. After decompression this becomes:

J=QwTI[5mRb`

After string-decompression:

Hello, World!"

After quote auto-completion:

"Hello, World!"

After which it is implicitly output.

Plumber, 1606 445 bytes

[]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
[[]=]=]=]=]=]=]
]
[[]=]=]=]=]=]=]=]=]=]=]=]=]
]
]
]
]
]
]
]
]
]
]
]
[[]=]=]=]=]=]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
[[]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
[[]=]=]=]=]=]=]=]
]
]
]
]
]
]
]
]
]
]
]
]
]
[[]=]=]=]=]=]=]=]=]=]=]=]
]
[[]=]
]
]
]
]
]
]
]
]
[[]=]=[[[[]=]=]=]=]=]=[]
]
]
]
[[]=]=]=]=[[]=]=]=[]
]
]
]
][]=]=]=]=]=]=]=]=]=[]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]
][[=

With some modifications of an idea by @dzaima, I've golfed 1161 bytes off of this. This one uses a single falling packet, incrementing each time it falls, and forks it off each time it reaches the right value to be outputted.

Old version

[]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
[[[[[[[[[[[[[[[[[[[[[[[[[[
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ] ]   ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
] ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
  ] ] ] ]     ]
              [[[[[[[[[]]
  ] ] ] ]     [ ]
    ] ] ]     [ ]
    ] ] ]     [ ]
    ] ] ]     [ ]
    ] ] ]     [ ]
    ] ] ]     [ ]
    ] ] ]     [ ]
    ] ] ]     [ ]
                [[[[[[
        ]     [ ] ]
        ]     [ ] ]
        ]     [ ] ]
              [   ]
              [   ]
              [   ]
              [
              [
              ]
              ]
              ]
]]]]]]]]]]]]]]]]]]]]]]]]]]
][[=

It's a little long. I could probably steal some tricks from a BF solution, maybe.

In Plumber, the program is divided into units, each of which are 2 characters wide. Each line is padded to the length of the longest line with spaces, which can be used to shorten programs. Each ] unit is an increment operator on a falling packet of information, which is dropped by the [] at the top. Chains of [[ can be used to duplicate packets and drop them one by one in different columns.

Wren, 29 bytes

System.print("Hello, World!")

Try it online!

Explanation

System.print(               ) // Output the following string:
             "Hello, World!"  // "Hello, World!"

Java, 82 bytes:

class Main{public static void main(String[]a){System.out.print("Hello, World!");}}

Intcode

Since Advent of Code will inevitably be adding more features to Intcode as this year's event progresses, I'll just treat the separate revisions as different languages, and add to this if a new one makes it shorter.

Day 2, N/A Bytes

Having no real way of outputting multiple values yet, the version in day 2 can't do a proper Hello World.

There is technically this 42-byte solution, but it feels like cheating because I'm pretty sure no interpreter can run it:

1,3,5,0,99,5735816763073854918203775149089

This program copies that really long number to memory location 0 (which counts as output) and then halts. The really long number happens to be Hello, World! when read in bigendian form as a string.

Day 5, 89 Bytes

In day 5, dedicated I/O instructions are added, so a proper Hello World is possible. The ability to use immediate values doesn't hurt either.

104,72,104,101,104,108,4,5,104,111,104,44,104,32,104,87,4,9,104,114,4,5,104,100,104,33,99

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.

Poetic, 324 bytes

the i/o case of HELLO
a good i/o drill is:say a HELLO
i said HELLO,saying it in Poetic
i code in Poetic,a good way to write a poem
a special piece for you
a special piece in machine writing for you
i already think i do pretty well writing for the machine poem
Poetic program syntax is nice
a perfect sorta poem and a program

Try it online!

This is nothing original, it's a straight port of the brilliant brainfuck answer from @KSab...but it turns out that it's the shortest representation of Hello, World! that I can find in Poetic. If anyone can golf this, please let me know; I'm definitely interested if someone can beat this solution!

Ruby, 19 bytes

puts"Hello, World!"

Simula (cim), 24 bytes

OutText("Hello, World!")

Try it online!

Over 750 answers and we can still find languages not yet submitted. Wowsers.

1+, 87 83 bytes

11+""+"""+"/*^/"+""+";\+"*"1+;/+""";;(|1+1+1+)";/^""1()"+()+"1+";+^;;";();/;;1+;

Try it online!

This should be very golfable, but it is hard to golf 1+ directly.

International Phonetic Esoteric Language, 16 bytes

"Hello, World!"o

"Hello, World!"  (push "Hello, World!")
               o (pop and print)

Cascade, 23 bytes

}ro
"""
l,H
d e
!Wl
"ol

Try it online!

This is about as compressed as it is possible to get. The } instruction is the put instruction, but it doesn't really matter what it does since we're just using it to execute the three of the instructions below it, all of which are ".

First we execute the left, which wraps around to be the rightmost column, printing Hello. Then right (which is the center column), printing , Wor. Finally directly below in the left column, we print ld!, terminating the string literal early rather than wrapping, to avoid printing the } as well.

Verbosity v2, 152 bytes

IncludeTypePackage<OutputSystem>
IncludeTypePackage<StringArray>
outpu=OutputSystem:NewOutput<DEFAULT>
OutputSystem:DisplayAsText<outpu;"Hello, World!">

Try it online!

Introducing Verbosity v2! This is a short as it gets, as variable names must be 5 characters or more. The ungolfed version isn't much different:

IncludeTypePackage<OutputSystem>
IncludeTypePackage<StringArray>

output = OutputSystem:NewOutput<DEFAULT>

OutputSystem:DisplayAsText<output; "Hello, World!">

Try it online!

And it's pretty obvious how it works.

Pxem, 0+17=17 bytes

Using the filename as data without counting the length is cheating. Therefore it is 17 bytes. (It even uses the filename extension as part of the program!)

Save the program as

Hello, World!.pxe

and the file contents should be empty.

Seed, 4154 4135 4117 4078 bytes

Explanation, quite long, along with the description of the generation algorithm on my home page (as per request in comments): link

Possibly smallest one can create in finite amount of time.

Feersum's generator has been outscored by 125 digits.

18 1999111369209307333809858526699771101145468560828234645250681099656696029279480812880779443148152835266354745917034724622145903651417563371730237765283326056988244774110441802133624468817714160177386022056512108401823787027806425684398448067970193332644167536135089961308323052217690818659345826221618714547471817786824952177760705661213021136861627615564344797191592895410701640622192392412826316893318666484043376230339929937013414786228802341109250367744273459627437423609306999946689714086908789713031946200584966850579209651689981508129953665360591585003323062426849065928803791631705897655870676902001410564547259097078231664817435753967511921076054045034302323796976905054512737624542497156263914722954936458789312271946701667519720841308380062811251340113402138536813062807047486584549696366881131076129644333426157514410757991556230404583924322168740934746079177400690540383270574734570453863131129670312070568678426587468145691141064452504683450565188718043501125177371576228281599163415914580472091806809959254536307112226422637068036069837636348250796013947548859219492684001888592443619271863264913733271796439829896342322684180478385639971904415730730155249230972472713598001454701479081682503703435292522488015910406951417625194589254609756805750713606175216991897729604817653297756338264018378339186646236428245791304007449872675676823828828025054891324604572924113135541994460293993994930010757779465315482913805320566037487246911578188713647298779820394853314711728701462997760060773720597833413054385989484972761510228922232188763499675904892361201334056531237561182096332707820332381472154893517831468669407424867949853884550905603295504680929068346527584718316837786318710085149722173684889784734888358566137013072868037395888296895408992035862679921478330680631465096402120764369879221964359613565641652779510635224788673321444028128955312660697375763703507924497355056468329176678508797277505818080245055083627993568557883893217501909841992899324584338401263402065617507377073719573642373296064002058833488593469308722954567388945161866200094063588423591356962865924188962743278147095803148276100759174767606637848987740320689762075562393521992008413240632519860537097220403160035470139899869535541445941688033346042941342229305392639867768112643798588915164061012851035069872578424685533430920913310727097269791325370108354115267003538502506307401037702631576755065238836157990287620373910423088628131973441805618500402407032751005850768445522318425479521483938945040598642922742796671148454685792926662105094734939468210307429214048710552195412807154088634170043145174020299723624868716804740205833308025010299791473201989330179511900752421521748244324520372384555472905196933204791343923384985673930225356512632819977168423365518584516873151142795940198973519372718229122661025988052451376835210066645728260048500257088773609522352231828810506243886764860621803233068079848240668323783996022507908005888468315483796728648978952610219628600082949325089555677853995177602958596492703349550377871982505777660804519503438416790609328789548538308170189581940118961959513239411467871900221985235702327603132341245854941342838886675363828149587290416073764877392438738417021129652498464495269870868163299830870636019233313974206364225614175115905798645888824666280593535350493547833757379214088677125769505793280646751090271497879000895725329057103702349349795211071357094147037863458426851391499872003703049553149335378055054176480977774050198041879243243264959205957441742983643583697591926138999543475339555662645088503078864968452030049140027407987267835123806661736568594687416676322591834962173789578844522343172160526435025531896189408441645468352864002987706103448393710107805248652709736711528349633758515438315407447026188178510124322920110858766628704828773265703683997486487094455425009292414948853993709223752434073750917088611480305840639869649933404702780843770306859066070919534638022435125602050780767420448917941603557783974740312706609928585387278690009349321957381507513875981113699582062422293555869483805964659436085153933836036107786

Try it online!

Original, 4154 byte version

Added per request of @JoKing, because the 1st program doesn't quite run on TIO, albeit being valid.

20 77698190481213510983405846204529755428212736563278528088055816123655499433757607718113585773285686740433752335768949721107461077652705328567448384490378909463204984642622585570301449419608763821501335954761638946551568252142160714228369356054944595121742743720935369219143086698092657062614382519069928478344861416117079283276656675368390764675728501797178208908097054412833019383889935034413095990596139618411133857423995278221670378808372393943846302426674985203826030563290800228881174929701934609803807325868775242909948272754141956168876233403760199007405891058308908050926690654387065882097924294620229833663324754801060691573338185912369627367088050915813931912943122729210762147280440619571047157836177316082899933374851699282897590433145623725705072835054748369992455883804733164985993447304652512229557984322495162682327137071900307763332392727562988633724175094951314863886096190608268953115914497741446723188169519334729165647294618083444761551231012944903572063441813639201051793052623561949314826491616145873848990439549320951496534538450810083853945092224500179417650727351532486362656533602860500906935826231374501097567347929533018944533000919137863885267937690665655625569011036163950983389810112758403211861147501289650757555111271813737813381172074709337306647481507917983021055643749698971365256395367215437223669891280521155247529741719633106765965869860677198632388808752014013939448563313855130972968670015202479226496876067874099463222366536167126653600056389712632892652810365218798697007191747287017174284819764736012653205048166550645507761123345279502597627995423826537299795220169894222867163817508592362092945387317777666016102146798532337718546431888424995701016828542559577710937459975677354300708252448630110787487122698124054544454425586794841157136743408274159313823745226919626156949004386804874236325506583268311452185182143521552429596087556634158778951670223004413763782647825362665491934988477225698133609360969370513836064317152213804169538880632390908441210809806024082600637872813704781431414342781727628446451808751293046212690472851527294326981763969926510021099532791692362104324026231160941956411410511639925420026544463125250979130259151326444714248961523031316570018708849878676230362246913063109584502143502908906243190007062857721367402065760878808920961082444422470813023453274563914735545463757909757689866565064353853099958949763412521666109346825939993377745919874506439752272141853783745051726268592621080457687000431023453539135927140364910898906534604541224314820195082362228787083990333757268808864746297304451768935814651205074884015268982492445996542040655715230139673520569765431617018824427859214902954216246257690105154030408059145566852643855789351907818461502260430297487602982850090037405732117988720732457199005151517240766953718440639691354185802798689950155164379549518496065038927905828230066053603755553745353618846804435103593395141938947781375633374976924393453162350331593801284839409264892975739791751842620029351535320807733966984270102067017902086335370470815153908942490581427972998999752666174807935897314584088695849094389002316139005810918748032068307783088481430339303809949409414892479892121893571274086727250767713365523021125610242269894861374297866741571608166536165735922984579027986499758294460652554897534526492251140681138244025665400003029337114012766773010641359450599171473565675885966777145500248501370644599274741842644014722083732709145488157998306684831419559774212264003518406013032514468522158218837161285401631773099549510145156007147884565387852623860047153609138110997222297132678660783411624002400927435687937355446057878202312894093195453248164648271580944753933355967626542678764854079218206499479071658357103085513937246462858404881973219571392564909528645166637501279457604649906515968389831094896970731573714836150178126997674563415266672131632765794599548356902607125568792417432226125654028873443580337866760487651905138461301986816386866811155111486155341154153322710638921116465132825486519667178335471102213200521032618562169530188826434060179505699797068436325168526618824444305122475837890944742004331675952611756641739756206337285946

Try it online!

Nandy, 159B

Simply sets the stack to bits 0 and 1 and then puts them in the output stack.

o::#o>oo>o>oooo>oo>oo>o>o>o>o>oo>o>oo>ooo>oo>o>oo>ooo>oo>o>oooo>oo>o>o>oo>oooo>o>oooooo>o>o>o>o>ooo>o>oo>o>oooo>o>ooo>oo>o>oo>oo>o>oo>ooo>oo>oo>o>oooo>o>oooo>o

anyfix, 14 bytes

“Hello, World!”

Simply the string, pushed onto the stack. Really boring.

(By the way, just use postfix for all operators in anyfix; this leads to the least confusion compared to infix modes and prefix modes, and anyfix is the easiest to understand in the postfix mode.)

TIO

Visual Basic Script, 21 bytes

MsgBox"Hello, World!"

You can try it by making a .txt file with that text in it, changing the extension to .vbs and running it.

EBCDIC Punched Card, 13 bytes

Disk Operating System/360, also DOS/360, or simply DOS, is a discontinued operating system for IBM mainframes. It was announced by IBM on the last day of 1964, and it was first delivered in June 1966.In its time, DOS/360 was the most widely used operating system in the world.

A typical configuration might consist of a S/360 model 30 with 32KB memory and the decimal instruction set, an IBM 2540 card reader/card punch, an IBM 1403 printer, two or three IBM 2311 disks, two IBM 2415 magnetic tape drives, and the 1052-7 console.

• Generator: http://www.kloth.net/services/cardpunch.php
• Scanner: https://www.masswerk.at/cardreader/

Triangular, 55 bytes

66+@*8C::6--::@@#2"+3^82*@3/#-<*#+/@"#+F<3/3@@#-7:*<

This one took a while. Also will be very difficult to golf, since there is zero no-ops in it, meaning you'll have to save 10 bytes to get it to a size 9 triangle in order to save any bytes

This expands out into this size 10 triangle:

         6
         6
       + @ *
      8  C :
     : 6 - - :
    : @  @ # 2
   " + 3 ^ 8 2 *
  @ 3 / # - < * #
 + / @ " # + F < 3
/ 3 @ @ # - 7 : * <

How it works

Note: this ignores all control flow characters and just looks at what gets run in order

66* Push 36
:: Duplicate it twice
2*# Output H, popping it
3*  Multiplies by 3, yielding 108
:   Duplicates
-7# Outputs e, popping it
@@  Outputs l twice, without popping it
3+@ Outputs o, without popping it
" Swaps, putting 36 at the top of the stack
:: Duplicates it twice
8+@  Outputs comma, without popping
C-#  Outputs space, popping the top of the stack
2*F+# Outputs W, popping it
"     Swaps back around, putting 111 at the top of the stack
@     Outputs o, without popping
3+@   Outputs r, without popping
6-@   Outputs l, without popping
8-#   Outputs d, whilst popping
3-@   Subtracts 3 from 36, giving !, and outputs it
6     Pushes 6, which does nothing

Try it Online!

C++ (gcc), 40 bytes

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

Try it online!

Using builtins are shorter since #include takes up a lot of bytes. I believe this solution is optimal.

33, 16 bytes

"Hello, World!"p

But that's boring, isn't it? Let's try with functions, instead.

56 bytes

{"Hello"p}'Hello'{", "p}', '{"World"p}'World'{"!"pi}qqqq

Here's something to be explained.

The string registers are initialised to "" when the interpreter starts. When the interpreter encounters a {, it copies all the code until the matching } and stores it as a function, labelled as what the destination string register was at the time (The destination string is set by single quotes).

Changes to the registers persist when changing stack frames (is that the right term?), so the explanation looks like this:

{                                                         (Creates function "")
  "Hello"                                                 (Stores "Hello" in the source string register)
         p                                                (Prints what is in the source string register)
          }'Hello'{                                       (Creates function "Hello")
                   ", "p                                  (Prints ", " after storing it in the source string register)
                        }', '{                            (Creates function ", ")
                              "World"p                    (Prints "World" after storing it in the source string register)
                                      }'World'{           (Creates function "World")
                                               "!"p       (Prints "!")
                                                   i      (Prints a newline)
                                                    }q    (Calls function "")
                                                      q   (Calls function "Hello")
                                                       q  (Calls function ", ")
                                                        q (Calls function "World")

This is a language I created. The source is in the link. I haven't made a Windows release of the interpreter yet, because I cannot figure out how to cross-compile. If you're on Windows, you'll have to compile it yourself.

Incalculate (2.0), 21 bytes

"!dlroW ,olleH"[pov?]

Probably won't get shorter than this.
Incalculate is an esoteric language I have written for fun, don't expect anything fancy. It uses 3 stacks for storage.

strict, 18 bytes

out: Hello, World!

Believe it or not, the space is required (hence the language name). In case the website dies, here's the interpreter download link.

Keg, 15 bytes

Hello, world!

Keg pushes all of the unrecognized commands onto the stack (with , and ! escaped). After the program terminates, it prints the content of the stack.

Turing Machine But Way Worse, 853 bytes

0 0 0 1 1 0 0
0 1 1 1 2 0 0
0 2 0 1 3 0 0
0 3 0 1 4 0 0
0 4 1 1 5 1 0
0 5 1 1 6 0 0
0 6 0 1 7 0 0
0 7 1 0 8 0 0
0 8 0 0 9 0 0
1 9 1 0 a 0 0
1 a 0 0 b 0 0
0 b 0 0 c 0 0
0 c 1 1 d 1 0
0 d 0 1 e 0 0
0 e 1 1 f 0 0
1 f 1 1 g 0 0
0 g 0 1 g 0 0
1 g 0 0 h 1 0
0 h 0 1 i 1 0
0 i 1 0 i 0 0
1 i 1 1 j 1 0
1 j 1 1 k 0 0
1 k 1 1 l 0 0
0 l 0 1 m 0 0
0 m 0 1 n 0 0
0 n 1 1 o 0 0
0 o 0 1 p 0 0
0 p 1 1 q 0 0
0 q 1 0 r 1 0
1 r 0 1 s 0 0
1 s 0 1 t 1 0
0 t 0 1 u 0 0
0 u 1 0 v 0 0
0 v 0 0 v 0 0
1 v 1 0 w 0 0
0 w 0 0 w 0 0
1 w 1 0 x 0 0
1 x 1 0 x 0 0
0 x 1 1 y 0 0
1 y 0 0 z 0 0
1 z 1 0 A 0 0
1 A 0 1 B 1 0
1 B 0 1 C 0 0
0 C 1 0 D 0 0
0 D 0 0 E 0 0
0 E 1 1 F 1 0
0 F 1 1 G 0 0
1 G 0 1 G 0 0
0 G 0 0 H 0 0
0 H 0 0 I 0 0
0 I 1 0 J 1 0
0 J 1 0 J 0 0
1 J 0 1 K 0 0
1 K 1 1 K 0 0
0 K 0 0 L 0 0
1 L 0 0 M 1 0
1 M 1 0 N 0 0
1 N 0 1 O 1 0
1 O 0 1 P 0 0
0 P 0 1 P 0 0
1 P 1 1 P 1 1

Try it online!

VTL-2, 21 bytes

1 ?="Hello, World!"

? is the I/O system variable in VTL-2. Byte count may seem off, but line numbers are always two bytes, and the CR at the end of the line is mandatory and counted. Space between line numbers and commands is also mandatory.

32 bit SPARC machine language on SunOS, 48 45 bytes

0x00:  40 00 00 02    call 0x8            ! PC relative jump, return addr to %o7
0x04:  82 10 20 04    mov  4, %g1         ! delay slot; select write() syscall
0x08:  90 10 20 01    mov  1, %o0         ! stdout is fd=1
0x0c:  92 03 E0 20    add  %o7, 32, %o1   ! put addr of string in %o1
0x10:  94 10 20 0d    mov  13, %o2        ! length of string
0x14:  91 D0 20 08    ta   %icc, %g0 + 8  ! call write()
0x18:  82 10 20 01    mov  1, %g1         ! select exit() syscall
0x1c:  91 D0 20 08    ta   %icc, %g0 + 8  ! call exit()
0x20:  48 65 6c 6c    "Hello, World!"
       6f 2c 20 57
       6f 72 6c 64
       21

Porting to 64 bit SPARC requires changing the argument of the trap instruction from 8 to 64.

To try this on a SunOS machine, compile and run the following C program.

const char main[]="x40x00x00x02x82x10x20x04x90x10x20x01x92x03xe0x20x94x10x20x0dx91xd0x20x08x82x10x20x01x91xd0x20x08Hello, World!";

Scala, 63 bytes

object Main{def main(a:Array[String])=print("Hello, World!")}

Try it online!

legit, 1 commit, 67 bytes (commit messages), 179 + 3 = 182 bytes (repository)

Commit tree:

* 63c5d78 "!dlroW ,olleH" put put put put put put put put put put put put put

The program is quite boring -- commits are expensive, and the messages are compressed, so there's little incentive to use proper control flow.

The program in its proper representation consists of 4 files:

.git/HEAD (21 bytes, an empty file here is still accepted by the interpreter, but git does not recognize the repository):

ref:refs/heads/master

.git/refs/heads/master (40 bytes):

63c5d7873f5b0ede65885bfdfd5c935827d6752a

.git/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 (15 bytes, xxd):

00000000: 78da 2b29 4a4d 5530 6000 000a 2c02 01    x.+)JMU0`...,..

.git/objects/63/c5d7873f5b0ede65885bfdfd5c935827d6752a (103 bytes, xxd):

00000000: 78da 04c1 4501 c030 0c00 c0bd a722 0e4a  x...E..0.....".J
00000010: 4137 6366 f0df bbf6 dcf7 f983 80a1 f89e  A7cf............
00000020: be07 6c34 52d7 32c6 b6e1 beb1 dab3 ef09  ..l4R.2.........
00000030: 9b41 3bb6 a83a 347d 8fe6 b1ac ff6f 3a1f  .A;..:4}.....o:.
00000040: f090 6763 c705 31a4 2415 cae5 5252 4cc9  ..gc..1.$...RRL.
00000050: 29ca 0f57 d0c9 cfc9 49f5 5052 2828 2d21  )..W....I.PR((-!
00000060: 1503 00bd ca30 75                        .....0u

Bitwise Cyclic Tag But Way Worse, 324 bytes

1111111111111111111111111111111111111111111111111111111110110101101010101110101101101110111010101110111010101110111110101101110101010110101010101011011011110111011111011110101101011101110101011101011010101011010101011n0200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Try it online!

VBS (Windows Script Host), 26 bytes

WScript.Echo "Hello, World!"

JS (Windows Script Host), 25 bytes

WSH.Echo("Hello, World!")

I don't know if someone did already post Windows Script Host JS.

Tamsin, 27 20 bytes

main='Hello, World!'.

This is an interesting language.

A Pear Tree, 25 bytes

print'Hello, World!'#»G²Ú

Try it online!

A Pear Tree programs are written in an arbitrary ASCII-consistent 8-bit character set; for codepoint 128 and above, the interpreter cares about the codepoint numerically, not the represented character. TIO uses Latin-1, so the above program is actually a Latin-1 decoding of the codepoints that make it up.

Explanation

print'Hello, World!' should be fairly self-explanatory. However, there is some choice available here; print"Hello, World!" would have been the same length, but leads to the resulting checksum being less printable.

The checksum is the interesting part of the program. In this program, that's the #»G²Ú at the end. For golfing, you'd want the shortest workable checksum, which is normally 4 or 5 bytes long. (It's a 32-bit checksum, so 4 bytes would normally be enough, but the checksum is also executed as code, and thus needs to be a valid command; the # starts a comment, so # plus 4 bytes is normally enough to add a checksum to anything.) The checksum doesn't have to cover the whole code, but does have to cover a prefix of the part of the code that actually runs; adding comments at the end is terser than adding them at the start, and we want to execute the entire program, so for this program, I caused the checksum to cover the entire program.

Although a Hello World program doesn't benefit much from the checksumming, we could have made use of the checksum behaviour to embed the Hello World program into a larger document or write multiple copies of the program so that if one gets corrupted, the others can still run. This makes A Pear Tree considerably more robust than most languages are.

JVM bytecode (OpenJDK asmtools JASM), 235 bytes

public class h {public static Method main:"([Ljava/lang/String;)V" stack 2 locals 1 {getstatic java/lang/System.out:"Ljava/io/PrintStream;";ldc "Hello, World!";invokevirtual java/io/PrintStream.println:"(Ljava/lang/String;)V";return;}}

Ungolfed

public class h {
    public static Method main:"([Ljava/lang/String;)V" stack 2 locals 1 {
        getstatic java/lang/System.out:"Ljava/io/PrintStream;";
        ldc "Hello, World!";
        invokevirtual java/io/PrintStream.println:"(Ljava/lang/String;)V";
        return;
    }
}

Pretty much the same thing as Jasmin, just with a different syntax.

axo, 22 bytes

"!dlroW ,olleH"[>[(#<

Try it online!

Pushes "Hello, World!" to the stack "!dlroW ,olleH"

Duplicates top of stack afterward, which results in "HHello, World!" [

Moves to the right >.

Duplicates it again, which results in "HHHello, World!" [

Outputs "H" while popping from the stack, so the stack is "HHello, World!" (

Pops the top of the stack, results in "Hello, World!" #

Moves left <

Pops the top of the stack, results in "ello, World!" #

Outputs "e" while popping from the stack, which results in STDOUT being "He" and the stack being "llo, World!" (

Duplicates the top of the stack, resulting in the stack being "lllo, World!" [

Moves right. >

And I'm sure you can figure out the rest. If you can't, I'll update a more indepth-explanation soon.

whenyouaccidentallylose100endorsementsinnationstates -  900   761   728   552  260 bytes

20280782166
114
fff#dff#dfffff#dfffffffffff#dfffffffffffffff#dffffffffffffffffffffffffffffffffff#dfffffffff#dfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff#dffffffffffffffffffffffffff#dfffffffffffffffffff#dffff#dffffffffff#dfffffffffff#d

Try it online!

Golfed down to 761 bytes by increasing the brute-forcer to seeds up to 9999, instead of 999

Golfed down to 728 bytes by increasing the brute-forcer to seeds up to 99999, instead of 9999

Golfed down to 552 bytes by increasing the brute-forcer to seeds up to 999999, instead of 99999

Golfed down to 260 bytes with the help of @ASCII_only

C# (Visual C# Interactive Compiler), 22 bytes

Write("Hello, World!")

Try it online!

I realize this question has an existing C# answer which presumably uses the traditional csc.exe compiler. This answers uses the csi.exe command-line REPL.

Clam, 15 bytes

p+[[ua+ua,]"!"]

Try it online!

Oh boy, he did it again, he started another language.

Explanation

All functions and operators in Clam are prefix

p+[[ua+ua,]"!"]
p                Print
 +               Addition
  [...........]  Argument list
   [......]        Standalone list
    u                Uppercase the first letter of..
     a               ..the string at dictionary index..
      +              ..42 (+) - 32 = 10, dictionary[10] = 'hello'
       ua,           Do the same as above for index 11, 'world'
                   End of list, standalone list concatenates its
                   contents as strings with ', ' as delimiter
           "!"     String literal
                 End of argument list, Addition also acts as string concat

Transpiled JS code:

console.log('Hello, World' + "!");

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

LC-3 object file, 36 bytes

.ORIG x3000
LEA R0, TEXT
TRAP x22
HALT
TEXT .STRINGZ "Hello, World!"
.END

This compiles to an object file:

ibug@ubuntu:~ $ hexdump -Cv hello.obj
00000000  30 00 e0 02 f0 22 f0 25  00 48 00 65 00 6c 00 6c  |0....".%.H.e.l.l|
00000010  00 6f 00 2c 00 20 00 57  00 6f 00 72 00 6c 00 64  |.o.,. .W.o.r.l.d|
00000020  00 21 00 00                                       |.!..|
00000024
ibug@ubuntu:~ $ stat -c "%s" hello.obj
36
ibug@ubuntu:~ $

ABC-assembler, 80 39 bytes

.start s
s
 print "Hello, World!"
 halt

Try it online!

ABC, 21 bytes

WRITE "Hello, World!"

Try it online!

+-=*/!&#, 64 Bytes

!!!!!!!++*!!!-*!---**+++*/!!!++*!!!!!+++++*!!++++*+++*&++++*&++*

This programming language was actually made by me on November 30th, and it's only useful for printing stuff. See here.

Symbolic Python, 175 157 147 136 bytes

_=-~(_==_)
_*=_-~_
__=_*_+~-~-_
_=('%'+`''`[~_/_])*-~-~_%(~-_*~-~-_,_*_+_/_,__,__,_*_-~_,',',' ',__-_+~_,_*_-~_,`_==_`[_/_],__,_*_)+'!'

Try it online!

I'm not sure this is optimal, but it sure was fun.

Explanation:

_=-~(_==_)           # Set _ to 2
_*=_-~_              # Set _ to 2*(2+2+1) = 10
__=_*_+~-~-_         # Set __ to 10*10+(10-1-1) = 108
_=                   # Set _ to
  ('%'+`''`[~_/_])      # %c, where c is coming from the character x0c
  *-~-~_                # Repeated 12 times
  %(...                 # Then format into that format string
  ~-_*~-~-_,              # (10-1)*(10-1-1) = 72  = 'H'
  _*_+_/_,                # 10*10+1         = 101 = 'e'
  __,                     #                   108 = 'l'
  __,                     #                   108 = 'l'
  _*_-~_,                 # 10*10+10+1      = 111 = 'o'
  ',',                    #                         ','
  ' ',                    #                         ' '
  __-_+~_,                # 108-10-(10+1)   = 87  = 'W'
  _*_-~_,                 # 10*10+10+1      = 111 = 'o'
  `_==_`[_/_],            # second letter of True = 'r'
  __,                     #                   108 = 'l'
  _*_                     # 10*10           = 100 = 'd'
)+'!'                   # Then add the last char    '!'
                     # And implicitly print _

Alchemist, 24 22 bytes

_->Out_"Hello, World!"

Try it online!

Kitten, 18 bytes

"Hello, World!"say

Keg, 15 8 bytes

«H%c¡|,!

Try it online!

Wow. It's been a while since I posted this. And boy oh boy how Keg has changed.

Explained

« #Start a special compressed string
H% #String compression code (SCC) for "Hello"
c¡ #SCC for "World"
|,! #Join "Hello" and "World" with a `,` and `!` to create "Hello, World!"
« #Close the special compressed string and implicitly print

Old Program

Hello, World!

Keg is a newly created stack-based, golfing language, which focuses on only having symbols as functions and keywords. As such, alphanumeric characters are pushed to the stack as letters (even spaces are pushed, meaning that they aren't NOPs).

Symbols that would normally be commands can be escaped using 's.

Xanathar, 24 bytes

printf["Hello, World!"];

Xanathar is a work in progress language, so it is rather hard to use.

Compilation:

$ xanathar helloworld.xan
$ ./helloworld.xan.o

Pixiedust, 153 bytes

++.*+..+...
++.*++..+.+
++.*++.++..
++.*++.++..
++.*++.++++
++.*+.++..
++.*+.....
++.*+.+.+++
++.*++.++++
++.*+++..+.
++.*++.++..
++.*++..+..
++.*+....+

Try it online!

Explanation

Each line of the program is:

• ++ indicating that this line prints the following to STDOUT;
• .*, the portal register indicating a number literal; and
• A sequence of + and . characters forming the binary representation of the character to be printed.

Backhand, 15 bytes

"ol!,ld elWHro"

Now on Try It Online thanks to Dennis!

Backhand is my first new language, taking inspiration from 2D languages like Befunge and ><>. However, it is 1D, but makes up for the missing dimension by having the pointer move more than one character at a time. Initially, the program starts at location 0 with step count 3.

"  !  d  l  r       " starts a string literal and starts pushing characters to the stack
 o  ,     W  o      Change direction and go left when you reach the end
  l  l  e  H  "     Switch direction again to go right and end the string literal
           H        Halt and output stack

Of course, it looks quite funny, since the program is also an anagram of just "Hello, World!".

ESOPUNK, 191

COPY 72 #STDO
COPY 101 #STDO
COPY 108 #STDO
COPY 108 #STDO
COPY 111 #STDO
COPY 44 #STDO
COPY 32 #STDO
COPY 119 #STDO
COPY 111 #STDO
COPY 114 #STDO
COPY 108 #STDO
COPY 100 #STDO
COPY 33 #STDO

Can probably save some bytes by copying a constant to X, and ADDI/SUBI from it.

ObCode, 68 bytes

Hexdump:

0000000: 9a62 c6c6 ca78 b665 a999 4ea9 5995 aa66  .b...x.e..N.Y..f
0000010: 53a9 6363 6665 3958 d996 a539 6363 6565  S.ccfe9X...9ccee
0000020: 6363 6656 5396 3636 3656 65a9 9594 ea8d  ccfVS.666Ve.....
0000030: 9599 6aa5 6339 6395 9599 594e 5656 5665  ..j.c9c...YNVVVe
0000040: aa99 94e5                                ....

Explanation

Unpacking the program gives the following object:

((())()(())((()())((())())((())())(()()(())))((()())())(())(()())()()(())(())(()()(()))()()()(()()())(())(()()())()()()(())(())(()()(()))()()(()())((())())((())())(())(())(()()(()))(()()())((())())(())(()())()()(()()(()))(()())((())())((())())(()()())(()()())((())())((())())(())(()()())(()()(()))(()())((())())((())())((())())(()()())(())(()())()()(())(()()())(()()(()))()()()((())())(()()())(())(()())()()()()(()()())((())(()))(()())((()))(()()())(()()())(())(()()())(()()(()))(()()())(()()())(()()())(())(()())()()()()(())(())(()()(()))(()()()))

Indented and commented, this gives:

( Start of main object
    (()) Define () (()) doing: (
        (()()) Save top stack value to register
        ((())()) ((())()) Push twice
        (()()(())) Concatenate
        This code will double an object
    ) ((()())())
    (()) (()()) Push 2
    () () Double it twice, producing 8
    (()) (()) Push 1
    (()()(())) Add: 8 + 1 = 9
    () () () Double thrice, producing 72
    (()()()) Output 72 = 'H'; Stack: empty
    (()) (()()()) Push 3
    () () () Double thrice, producing 24
    (()) (()) (()()(())) Add 1, producing 25
    () () Double twice, producing 100
    (()()) ((())()) ((())()) Duplicate and save to register
    (()) (()) (()()(())) Add 1, producing 101
    (()()()) Output 101 = 'e'; Stack: 100
    ((())()) Load 100 from register
    (()) (()()) Push 2
    () () Double twice, producing 8
    (()()(())) Add 100 + 8 = 108
    (()()) ((())()) ((())()) Duplicate and save to register
    (()()()) (()()()) Output both 108 = 'l'; Stack: 100
    ((())()) ((())()) Load 108 twice
    (()) (()()()) Push 3
    (()()(())) Add 108 + 3 = 111
    (()()) ((())()) ((())()) ((())()) Triplicate
    (()()()) Output 111 = 'o'; Stack: 100, 108, 111, 111
    (()) (()()) Push 2
    () () Double twice, producing 8
    (()) (()()()) Push 3
    (()()(())) Add 8 + 3 = 11
    () () () Double thrice, producing 88
    ((())()) Load 44, saved by the last doubling
    (()()()) Output 44 = ','; Stack: 100, 108, 111, 111, 88
    (()) (()()) Push 2
    () () () () Double four times, producing 32
    (()()()) Output 32 = ' '; Stack: 100, 108, 111, 111, 88
    ((())(())) Use 88 as new stack
    (()()) Load 1
    ((())) Exit the stack which is now 87
    (()()()) Output 87 = 'H'; Stack: 100, 108, 111, 111
    (()()()) Output 111 = 'o'; Stack: 100, 108, 111
    (()) (()()()) Push 3
    (()()(())) Add 111 + 3 = 114
    (()()()) Output 114 = 'r'; Stack: 100, 108
    (()()()) Output 108 = 'l'; Stack: 100
    (()()()) Output 100 = 'd'; Stack: empty
    (()) (()()) Push 2
    () () () () Double four times, producing 32
    (()) (()) Push 1
    (()()(())) Add 32 + 1 = 33
    (()()()) Output 33 = '!'
) End of main object

? ?, 21 bytes

?("Hello, World!")

Try it online!

This is a language written in Cuneiform, and uses Sumerian words as keywords.

At its heart, this is just a translation of Python into Sumerian, but in the future there will be new features added, such as the Babylonian numeral system (which works in base 60).

Because it relies heavily on unicode, this is not going to be a very good golfing language.

µ6, 25 bytes

,200,245,300,300,303,112,52,223,303,310,300,244,53

Try it online!

Explanation

Just apply the ASCII code-points to the pairing function , - strings/string-manipulation is not really the strength of µ6 (I guess nothing really is).

Flobnar, 53 42 41 bytes

^{-12 thanks to @JoKing}

!dlroW ,olleH
0
:| <@6
g>,
0_^> +
:
- <

Try it online! (requires the -r and -i flags)

Flobnar is an interesting 2D language vaguey similar to Jellyfish. It shares a creator and many of its instructions with Befunge.

Befunge is an "instruction-based" language, in that the functionality of most commands is encapsulated by an effect. Flobnar, on the other hand, is an "expression-based" language, in that the functionality of most commands is encapsulated by a return value. For example, the 4 term always returns 4, the > term is a tail call to the cell to the east, and the + term returns the sum of the terms to its north and south.

The relevant terms used by this program are:

• @ indicates the starting point of the program. @ evaluates the term to its west, and the result of this is the return value of the program (this is printed by default; the -r interpreter flag is needed to disable this behavior).
• lets evaluation "pass through" (it is a tail call to the cell opposite to the direction from which it was evaluated).
• ^>v< are tail calls to the cells in the direction they point.
• Digits return themselves.
• # is like , except that is jumps to the cell two steps away, like Befunge's # command.
• evaluates the cell to the south to get an argument, then lets evaluation pass through to the other side with the new argument. After evaluation is finished, the original argument is restored.
• : returns the current argument.
• + returns the sum of the cells to the north and south.
• - returns the difference of the cell to the north and the cell to the south.
• ! evaluates the cell on the other side, and returns 1 if it is 0 and 0 otherwise.
• g evaluates the cell to the north to get an x-coordinate, the cell to the south to get a y-coordinate, and returns the Unicode codepoint of the cell at those coordinates.
• | evaluates the cell on the other side. If the result is 0, it returns the cell to the south; otherwise, it returns the cell to the north.
• _ evaluates the cell on the other side. If the result is 0, it returns the cell to the west; otherwise, it returns the cell to the east.
• , evaluates the cell on the other side to get a codepoint and outputs the Unicode character with that codepoint. It always returns 0. This is one of the few non-referentially-transparent operations in the language.
• This program evaluates the invalid term l. This would be an error, but -i will cause invalid characters to be ignored (treated as ).

This program defines a recursive function that takes a single argument x and always returns 0. It looks something like this in Python:

def f(x):
    if x:
        print(playfield[x, 0])
        return f(x - 1)
    else:
        print(playfield[x, 0])
        return 0

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

Rockstar, 21 bytes

Shout "Hello, World!"

Yeah, kinda boring... oh well.

Bootable x86 machine code, 512 bytes

Hexdump:

31 c9 8e d9 be 10 7c b1  0d ac b4 0e cd 10 e2 f9  |1.....|.........|
48 65 6c 6c 6f 2c 20 57  6f 72 6c 64 21 00 00 00  |Hello, World!...|
*
00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|

* represents 464 bytes of padding required to place the bootable flag (55 aa) at offset 510.

This is the same as the following assembler code, which can be assembled using nasm hello.asm -f bin -o hello.bin, assuming the assembler code is in a file called hello.asm

[ORG 0x7C00]
[BITS 16]

    xor cx, cx      ; Set cx to 0
    mov ds, cx      ; Set ds to cx (0)
    mov si, msg     ; Set si to the address of the message
    mov cl, 13      ; Set cx to 13 (the size of the message)
print_loop:         ; For each character in the message:
    lodsb           ;   Set al to the character
    mov ah, 0x0E    ;   Set ah to 0x0E
    int 0x10        ;   Call interrupt 0x10 (video services) with ah set to 0x0E (print al to screen)
    loop print_loop ;   Decrement cx and continue the loop if cx > 0

msg:
    db 'Hello, World!' 

times 510 - ($-$$) db 0
db 0x55
db 0xAA

Running

The code can be runned with QEMU using the following command, assuming the binary code is saved in a file called hello.bin:

qemu-system-x86_64 -drive format=raw,file=hello.bin

Q#, 43 bytes

function H():String{return"Hello, World!";}

Try it online!

Might as well put it out there. Q# is Microsoft's programming language for quantum computers, not that there's anything quantum happening here.

"Now hold on a moment! This isn't a complete program!"--You, probably.

Well, it's not actually possible to write a complete program in Q#. You always have to call it from a different language. So I'm just submitting a "function", although note that while Q# is a .NET language, the function keyword actually defines a class and not a method, and the submission is equivalent to the following C# code:

public class H : Operation<QVoid, String>, ICallable
{
    public H(IOperationFactory m) : base(m)
    {
    }

    String ICallable.Name => "H";
    String ICallable.FullName => "qsharp.H";
    public override Func<QVoid, String> Body => (__in) =>
    {
        return "Hello, World!";
    }

    ;
    public override void Init()
    {
    }

    public override IApplyData __dataIn(QVoid data) => data;
    public override IApplyData __dataOut(String data) => new QTuple<String>(data);
    public static System.Threading.Tasks.Task<String> Run(IOperationFactory __m__)
    {
        return __m__.Run<H, QVoid, String>(QVoid.Instance);
    }
}

You can use this link to "disassemble" Q#.

Sisi, 21 bytes

0print"Hello, World!"

Try it online!

TapeBagel, 511 bytes

%% %++ %++ %++ %++ %++ %++ %++ %++ @* ## %++ %++ %++ %++ %++ @* ## %++
%++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ @* @* ## %++ %++ %++ %++
%++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ @* ## @* %++ %++ %++ %++
%++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ @* ## %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ @* ## %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ %++ %++ %++ @* ##  %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
%++ %++ @* ## %++ %++ %++ %++ @* ##

%# - adds one to the integer index.

%% - resets the integer index to zero.

%& - the integer that the integer index is pointing to is inputted into the program.

#% - sets all of the integers to one.

## - resets all of the integers to zero.

&& - pauses the program.

&@ - clears the screen.

%++ - adds one to the integer that the integer index is pointing to

@[ int ] - outputs the integer as a character (1 = A, 2 = B, ... 26 = Z)

* - integer 0

Z80Golf, 19 bytes

00000000: 674a 4343 4003 0f78 405d 434b 0e76 7e23  [email protected]@]CK.v~#
00000010: e5ee 2f                                  ../

Try it online!

Z80Golf is, essentially, a Z80 machine hooked up to $8000=putchar and $8003=getchar. The source code is a binary copied to $0000 (all other memory is zeroed out, just like the registers); execution starts there and runs until a halt instruction.

It was designed by mokehehe on anarchy golf for code golf competitions there, but seems to have fallen into disuse. It's really fun to golf in, but excelling in it requires a pretty thorough understanding of the Z80 chip (that I myself don't even have, but some golfers like kodera and *yuko* do, and every solution they write is very clever.)

A naïve Hello, World! program might look like this:

start:
  ld a, (ix+hello)
  or a
  jr nz, okay
  halt
okay:
  call $8000  ; putchar
  inc ix
  jr start
hello:
  db "Hello, World!"

It assembles into a 27 byte binary. It even cheats a little bit: we don't need to explicitly zero-terminate the string "Hello, World!" ourselves, as all the memory past our source code is zeroed already. And it's still a fair bit longer than our 19-byte solution.

So how does the 19-byte solution work?

It doesn't look much like a Hello, World! program when disassembled:

  ld h,a
  ld c,d
  ld b,e
  ld b,e
  ld b,b
  inc bc
  rrca
  ld a,b
  ld b,b
  ld e,l
  ld b,e
  ld c,e
  ld c,0x76
  ld a,(hl)
  inc hl
  push hl
  xor 0x2f

We can look at the program in a slightly more revealing manner.

  db 47 ^ 'H'  ; 67  ld h, a
  db 47 ^ 'e'  ; 4a  ld c, d
  db 47 ^ 'l'  ; 43  ld b, e
  db 47 ^ 'l'  ; 43  ld b, e
  db 47 ^ 'o'  ; 40  ld b, b
  db 47 ^ ','  ; 03  inc bc
  db 47 ^ ' '  ; 0f  rrca
  db 47 ^ 'W'  ; 78  ld a, b
  db 47 ^ 'o'  ; 40  ld b, b
  db 47 ^ 'r'  ; 5d  ld e, l
  db 47 ^ 'l'  ; 43  ld b, e
  db 47 ^ 'd'  ; 4b  ld c, e
  db 47 ^ '!'  ; 0e  ld c,
  halt         ; 76        $76
  ld a, (hl)
  inc hl
  push hl
  xor 47
               ; 32749 nop instructions, and then:
               ; putchar(A)
               ; ret

Whenever the PC becomes $8000, Z80Golf is programmed to write the byte in register A to STDOUT, and then effectively execute a ret (the PC is set to (SP) and SP is incremented by 2). In our code, instead of using call $8000 to access this behavior, we let the PC wade through a sea of nops (opcode 00) from $0013 to $7fff.

Keeping this in mind, the code will run as follows:

• Execute some meaningless instructions (effectively NOPs), starting from ld h,a.
• Set A to mem[0] ^ 47, which is 'H'.
• Increment HL and push it ($0001).
• Fall through to putchar, and return to the $0001 we pushed.
• Execute some meaningless instructions, starting from ld c,d this time.
• Set A to mem[1] ^ 47, which is 'e'.
• Increment HL and push it ($0002).
• Fall through to putchar, and return to the $0002 we pushed.
• …
• Set A to mem[12] ^ 47, which is '!'.
• Fall through to putchar, and return to the $000d we pushed.
  • We finally jump into the argument of the ld c, $76 — and $76 is the halt opcode!

Of course, the constant 47 was carefully picked so that none of the first instructions 13 influence the execution of the code, and the last one is some opcode that takes a single-byte argument, “hiding” the halt opcode until we jump there after printing '!'.

Thing, 37 bytes

Pushes the characters to the stack one by one (the second "l" is made with duplication, saving 1 byte), then concatenates them.

!dlroW ,oldeH++++++++++++

Try it online!

Nikud, 672 bytes

ֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֱֲֳֳֳֳֳֳֳֳֳֳֳֳֳֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶֶַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַַָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָָ

Try it online

Even though it has tons of bytes, it's top 3 in width, as all the characters are diacritical marks.

There isn't much useful to explain. The character codes are put in reverse order into the stack using mostly אֱ (push 1), אֶ (dup) and אַ (add). Then אֵ (print as char) is called 13 times.

Another thing that adds to the byte count is that each character is represented by 2 bytes in UTF-8. So it's actually 336 characters.

brainfuck, 137 bytes

++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.>+.+++++++..+++.<<++++++++++++++.------------.>+++++++++++++++.>.+++.------.--------.<<+.

Try it online!

Explained :

++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.                       H
>+.                                                                    e
+++++++..                                                             l l
+++.                                                                   o
<<++++++++++++++.                                                    comma
------------.                                                        space
>+++++++++++++++.                                                      W
>.                                                                     o
+++.                                                                   r
------.                                                                l
--------.                                                              d
<<+.                                                                   !

This can definitely be golfed. (World record is 72 bytes so I already know that)

This is basic hard coded answer, simply gets the Ascii value, resets and keeps going

brainfuck, 210 bytes

-[>+<-------]>-.[-]<-[>++<-----]>-.+++++++..[-]>+[+>+[<]>->]<.[-]--[>+<++++++]>+.[-]>-[-[-<]>>+<]>-.[-]-[>+<---]>++.[-]>+[+>+[<]>->]<.[-]>+[-->++[<]>-]>.[-]>+[++[++>]<<+]>+.[-]-[>++<-----]>--.[-]>-[-[-<]>>+<]>.

Try it online!

Explained :

-[>+<-------]>-.                                               H
[-]                                                             
<-[>++<-----]>-.                                               e
+++++++..                                                     l l
[-]                                               
>+[+>+[<]>->]<.                                                o
[-]
--[>+<++++++]>+.                                               ,
[-]
>-[-[-<]>>+<]>-.                                             space  
[-]
-[>+<---]>++.                                                  W
[-]
>+[+>+[<]>->]<.                                                o
[-]
>+[-->++[<]>-]>.                                               r
[-]
>+[++[++>]<<+]>+.                                              l
[-]
-[>++<-----]>--.                                               d
[-]
>-[-[-<]>>+<]>.                                                !

Ahead, 17 bytes

"!dlroW ,olleH"W@

A (very-unfinished at the time of this writing) fungelike. This works on the current master version.

Ahead is my first esolang (well... that actually has progress). It borrows a lot of concepts from Befunge and ><> but hopefully it provides enough unique features to be interesting. I particularly want to provide features that can improve code density and golfing, one of which is included in this answer.

W is called "Writewhile". This pops cells from the stack and prints them as chars, until it encounters a 0. The 0 is popped and discarded (not printed). Since stringmode pushes a 0 to the stack when it starts, this makes printing strings rather easy.

"!dlroW ,olleH"    push chars to stack
               W   pop and print until 0
                @  kill head

Try it online!

HadesLang, 20 19 bytes

-1 byte thanks to Oliver

out:'Hello, World!'

tinyBF, 94 bytes

+|=++=>=+=|>>+>=+++++>>|>++>+++|=>=+===>>>+==>>====+++|==>=|>>>>===+++===++++++==>>+===>>>>+==

Try it online!

I noticed there wasn't a tinyBF answer here. This is based on Ksab's record-breaking brainfuck answer.

BrainfuckSubstitutor, 65 bytes

_--!+++?>>/<<
+[_>-[?+>__-/]<_<_-]>-.>?+.?..![.>]//.!.___./-.??+.

Based off KSab's Brainfuck answer.

Hexagony, 23 bytes

H;_/201;lQP/oe;/W_|@dr

Try it online!

----

This was found with a brute force program. Time taken:

In 0 days 0 hours 52 minutes 56.4935 seconds

I suspect this is optimal.

2DFuck, 157 150 bytes

.!.!..!.!....!..!..!.!.!.x[!.!..!.!..!..rv].!..!.!....!..!.!.!..!....!.!......!.!.!.!.!...!.!..!.!....!.!...!..!.!..!..!.!..!...!..!..!.!....!.!....!.

Try it online!

Print He, print l twice, print o, World!

Aubergine, 29 bytes

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

Where 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.
               !dlroW ,olleH

]=[, 164 bytes

[=======[==]]=[[=[[=]]=[[=[[========]]][]=[]=[[=[=[=]]][]=[[====[====]]=[[===[==]]=[[========[=======]]=[]=[[=[=[====]]=[[=[[========]]=[[=[[]]=[[===[===]]=[[=[]]=[

]=[ was a language which only uses the symbols ], =, and [.

The ]=[ interpreter is written in 12-Basic.

Zig, 81 bytes

pub fn main()!void{try(try@import("std").io.getStdOut()).write("Hello, World!");}

Try it online!

IO, 20 Bytes

"Hello, World!"print

Other possibility, 21 22 Bytes

write("Hello, World!")

Unnamed, 14 Bytes

Unnamed is an unfinished language, only custom output is supported at the time of posting this. But it works.

!Hello, World!   

Explanation

! -> user specified output
Hello, World -> string

Subskin, 47 bytes

48
6f
2
a
1
4
1
4


a
3
3

43
4f
18

-3
3
b
4e

Try it online!

So Ruby allows negative indices.

Beatnik, 111 bytes

k zzzzzzzzc k xx k x k d k k k zzxa k zzzzzzzzf xw k zd z xw xo k k k x xw k zk
k zzzzzzzzzzxx qs z xo xw xj kd

Try it online!

Non-crashing version, 117 bytes

k zzzc xw xw z k xx k x k d k k k zzxa k zzzzzzzzf xw k zd z xw xo k k k x xw k zk
k zzzzzzzzzzxx qs z xo xw xj kd xo

Try it online!

Grass, 463 446 bytes

It exits with a crash. Append vw to get a non-crashing version (448 bytes).

wWWWwWWWWwWWWWWwvwwWWwWWWwvWwWwwwwwWWWwWWWwWWWWWwvwWWwwwwwwwwwwwWWWwWWWWWwWWWWwvwWWwwwwwWWWWWWWWWWWWwWWWwvWwwwwwwwwwwwWWwwwwwwWWWWWWWWwWWWWWWWwwWWWWWWwwwwwwwvwWWWWWWWwwwwwwwwwWWWWWWWWWWWWWwWWWwvWwwwwwwwwwwwwwwwwwWWwwwwwwwwwwwwWWWWWWWWWWWWWWWWWwvwWwWwwwwwwwwWwwwwwwWwwwwwwWwwwwwwwWwwwwwwwWwwwwwwwwwwwwwwWWWWWWWWWWWWWWWWWWwvwwWWWWWWWWWWWWWWWWWWWWWWwWWWwwwvWWwWWWWWWWWWWWWWWWWWWWWWwwwwWWwwwwwwwwwWwwwwwwWwwwWwwwwwwwwwWWWWWWWWWWWWwWwwwwwwwwwwwwwwwwww

Try it online!

Based on the TIO example. I think it was from this page by rst76 (613 bytes with lowercase w).

wWWWwWWWWwWWWWWwv                      x -> x + 3
wwWWwWWWwv                             f -> apply f twice (Church numeral 2)
Ww                                     f -> apply f 2**2 = 4 times
Wwwwww                                 x -> x + 4
WWWw                                   x -> x + 8
WWWw                                   x -> x + 32
WWWWWw                                 x -> x + 64
vwWWwwwwwwwwwwwWWWwWWWWWwWWWWw         f -> f(u+2 + 64 + 64 + 32) = f(23)
vwWWwwwwwWWWWWWWWWWWWwWWWwv            f -> f(23 + 8 + 1) = f(32 space)
Wwwwwwwwwwww                           (f->f(32))(x->x+1) = 33 !
WWwwwwww                               (f->f(32))(x->x+8) = 40
WWWWWWWWw                              40 + 4 = 44 ,
WWWWWWWww                              40 + 32 = 72 H
WWWWWWwwwwwww                          (f->f(23))(x->x+64) = 87 U+2
vwWWWWWWWwwwwwwwwwWWWWWWWWWWWWWwWWWwv  f -> f(32 + 64 + 4) = f(100 d)
Wwwwwwwwwwwwwwwwww                     (f->f(100)(x->x+1) = 101 e
WWwwwwwwwwwwww                         (f->f(100)(x->x+8) = 108 l
WWWWWWWWWWWWWWWWWw                     108 + 3 = 111 o
vw                                     begin function
Ww                                       c -> print c; return this function
Wwwwwwwww                                print H
Wwwwwww                                  print e
Wwwwwww                                  print l
Wwwwwwww                                 print l
Wwwwwwww                                 print o
Wwwwwwwwwwwwwww                          print ,
WWWWWWWWWWWWWWWWWWw                      print space
vwwWWWWWWWWWWWWWWWWWWWWWWwWWWwwwv      f = f -> c -> print c; return f(f)
                                       f(f) will return itself as a quine.
WWw                                    Apply the first half of output with
                                         the previous function as argument.
WWWWWWWWWWWWWWWWWWWWWwwww              111 + 3 = 114 r
WWwwwwwwwww                            print U+2
Wwwwwww                                print o
Wwww                                   print r
Wwwwwwwwww                             print l
WWWWWWWWWWWWw                          print d
Wwwwwwwwwwwwwwwwwww                    print !

Generator based on ASCII-only's (too long to post in a comment).

brainfuck, 72 bytes

+[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.

Try it online!

And the original non-wrapping 76 byte solution:

+[+[<<<+>>>>]+<-<-<<<+<++]<<.<++.<++..+++.<<++.<---.>>.>.+++.------.>-.>>--.

Try it online!

Other shortest known (to my knowledge) solutions I've found

'Hello, world!' 77 bytes:

+[+++<+<<->>>[+>]>+<<++]>>>>--.>.>>>..+++.>>++.<<<.>>--.<.+++.------.<<<-.<<.

Try it online!

'hello, world!' 70 bytes:

+[>>>->-[>->----<<<]>>]>.---.>+..+++.>>.<.>>---.<<<.+++.------.<-.>>+.

Try it online!

These were found using a c++ program I wrote here: https://github.com/ksabry/bfbrute

Note: I originally wanted to clean up this code before I posted it to make it actually somewhat readable and usable, but since I haven't gotten around to it in over a year I figure I'll just post it as is. It makes heavy use of templates and compile time constants for any potential optimizations and it has a bunch of commented out code from my testing but no helpful comments so sorry but it's a bit horrible.

There is nothing terribly clever about the code, it's brute forcer at it's core, however it is quite optimized. The major optimization is that it first iterates through all programs without loops (no [ or ]) up to a specified length (16 currently) and caches an array of all the changes it will make on the data array. It will only store a single program per unique array of changes so for example only one of >+<<-> and <->>+< will be stored. It then iterates through all possible programs which are composed of any program in this cache with any combination of loops between them. After executing each program it does a simple greedy hunt and peck for the characters and appends this to the end of the program.

After running this through the space of all programs I noticed that almost all the shortest programs (up to length ~19) were of the form *[*[*]*]. Restricting the search to programs of this form sped up the search considerably. The current record holder was found at length 27. This one was actually computed to be length 74, but I noticed a particular sequence .>.>.>. which was lucky enough to have a 0 in the data cell to it's right allowing it to be simplified to [.>]< bringing it down to 72.

I let it run for quite awhile and completed the search with the current parameters up to length 29, I suspect it will be difficult to beat the current one by simply going higher, I think the most promising approach would probably be increasing the search space in some intelligent way.

Whirl, 955 733 bytes

-~200 bytes using implicit modulo when output magic - I haven't checked anywhere close to all the simple possibilities, so this might be very suboptimal.

It might be possible to use memory/the operations wheel value as extra storage to make things shorter, but all approaches I've tried using those are not golfier than the naive one

1100001110010001111100110000000000000100000100000100000110000010000100100010001000000000000111110001111000111110001111000000000000011110000011100100011001111110001110011111000000000000000000000000000100100110000001111110001110011111000000000001001000100010000000000001111100000111110001001000110001000111110000011110000000000000000010001001100111111000100111110011000000000000000000000000010000011000000000110010001100010000000000011111000001111000000000000000000111110001111000111110001111000001001001100111111000111001111100000000000100100111001111110001111001111100000000000000000000000111100000111001000111001111110001111001111100000000000000000000000000000001111000001110010010001000000000000000000000000111110000011111000100100

Try it online!

Readable:

1 _
: ; _ + _ + _ + _ : _ + _ : _ * _ + _ : .
      + _ + _ + _ + : - _ + _ + _ + _ - _ : . _ :
      + _ + _ + _ + _ + _ + _ + _ : . _ . _ :
      + _ + _ + _ : .
      + _ + _ + _ + : + _ : .
      * _ - _ + _ + _ + _ + _ : . _
: ; _ + _ + _ + _ + _ + _ + _ : _ * _ * _ : .
      * _ * _ * _ - _ + _ + _ + _ + _ + : - _ + _ : . _ :
      + _ + _ + _ : . - :
      + _ + _ + _ + _ + _ + _ - _ : . - :
      + _ + _ + _ + _ + _ + _ + _ + _ - _ : .
      + _ + _ + _ + _ + _ + _ + : + _ : .

Every command switches operation wheels, starting from the operation wheel. Note that the cost depends on the current and previous command of the wheel, which is why there are so many no-ops.

Each character is on its own line, except for the two ls in a row. Some constructs used here are:

• : ; - load the 1 from operation value into math value
• _ + - add memory to math value - this can be used for e.g. repeated additions to emulate multiplications
• _ * - square. This is used for H since 72 = 8 * 8 + 8
• : . _ - store math value to memory, output, switch back to math wheel

Lines ending with : indicate the 1 from the operation wheel is being loaded, but the math value is not being overwritten. This is useful when consecutive characters are close in character codes.

Operation wheel commands

• 1 - set (operation) value to 1
• : - store value into memory. In this program it's always 1
• . - output chr(memory)

Math wheel commands

• + - add memory to (math) value - this is different to operation value
• * - multiply memory with value
• - - negate value - this is the only way to subtract
• ; - load memory into value
• : - store value into memory

See the language page for descriptions of unused commands

Try it online!

Lorale 37 (36) bytes

This is a language I am making. It shouldn't count as a loophole, as I am making this legitimately, but a hello world program requires you to pass this to the interpreter as args:

;Main{§vmain(){¶"Hello, world!"}};

Alternatively, the program could be put into the semi-IDE as:

Main{§vmain(){¶"Hello, world!"}};

making it 36, not 37 bytes.

Main{                                 Defines the main class
     §v                               Defines a void
       main(){                                       named main
              ¶"Hello, world!";       Prints "Hello, world!"
                              }};     Closes the main method and class

Logo (programming language) - 20 bytes

PRINT [Hello, World!]

Or even more exciting version:

to helloworld
 hideturtle
 fd 20 left 180
 fd 40 left 180
 fd 20 right 90
 fd 20 left 90
 fd 20 left 180
 fd 40 left 90
 fd 20 left 90
 fd 20 right 90
 fd 20 right 90
 fd 10 right 90
 fd 20 left 90
 fd 10 left 90
 fd 30 left 90
 fd 40 left 180
 fd 40 left 90
 fd 20 left 90
 fd 40 left 180
 fd 40 left 90
 fd 40 left 90
 fd 20 left 90
 fd 20 left 90
 fd 20 left 90
 fd 60 left 90
 fd 40 left 180
 fd 40 left 90
 fd 20 left 90
 fd 20 left 180
 fd 20 left 90
 fd 20 left 90
 fd 40 left 180
 fd 40 left 90
 fd 40 left 90
 fd 20 left 90
 fd 20 left 90
 fd 20 left 90
 fd 40 left 90
 fd 20 right 90
 fd 20 right 90
 fd 5  left 90  
 fd 5  left 90  
 fd 25 left 180
 fd 40 left 90
 fd 40 left 90
 fd 20 left 90
 fd 20 left 90
 fd 20 left 90
 fd 20 left 90
 fd 40 left 180
 fd 40
end

lt 90 pu fd 200 pd rt 90 helloworld 

Output:

Shakespeare Programming Language, 755 749 715 612 605 592 bytes

-34 bytes thanks to jimmy23013

-And a whole 107 bytes more! Wow!

,.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:You big big big cat!Puck:You is the sum ofI the square ofI!Speak thy!You is the square ofthe sum ofI a big cat!Ajax:Remember the sum oftwice twice you a cat!Remember I!You is the sum ofI you!Puck:You is the sum ofyou a cat!Speak thy!You is the sum ofa big cat a cat!Ajax:Speak thy!Speak thy!Remember you!You is the sum ofyou I!Speak thy!Remember the sum ofyou I!Remember you!You big big big big big cat!Puck:You is the sum ofI twice twice you!Speak thy!Ajax:Remember the sum oftwice I a pig!Scene V:.Ajax:Speak thy!Recall!Let usScene V!

Try it online!

Non-erroring version, 626 bytes

,.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:Remember I!You big big big cat!Puck:You is the sum ofI the square ofI!Speak thy!You is the square ofthe sum ofI a big cat!Ajax:Remember the sum oftwice twice you a cat!Remember I!You is the sum ofI you!Puck:You is the sum ofyou a cat!Speak thy!You is the sum ofa big cat a cat!Ajax:Speak thy!Speak thy!Remember you!You is the sum ofyou I!Speak thy!Remember the sum ofyou I!Remember you!You big big big big big cat!Puck:You is the sum ofI twice twice you!Speak thy!Ajax:Remember the sum oftwice I a pig!Scene V:.Ajax:Speak thy!Recall!Be you nicer zero?If solet usscene V!

Try it online!

An improvement over the previous community wiki answer.

Explanation:

,.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]   #Initialise Ajax and Puck

Ajax:You big big big cat!                    #Set Puck to 8
Puck:You is the sum of I the square of I!    #Set Ajax to 8+8*8=72 ('H')
Speak thy!                                   #Print 'H'
You is the square of the sum of I a big cat! #Set Ajax to (8+2)^2=100 ('d')
Ajax:Remember the sum of twice twice you a cat! #Push 2*2*8+1=33 ('!') to Puck's stack
Remember I!                                  #Push 'd' to Puck's stack
You is the sum of I you!                     #Set Puck to 100+8 ('l')
Puck:You is the sum of you a cat!            #Set Ajax to 100+1=101 ('e')
Speak thy!                                   #Print 'e'
You is the sum of a big cat a cat!           #Set Ajax to 3
Ajax:Speak thy!Speak thy!                    #Print 'll'
Remember you!                                #Push 'l' to Puck's stack
You is the sum of you I!Speak thy!           #Set Puck to 108+3=111('o') and print it
Remember the sum of you I!                   #Push 111+3=114 ('r') to Puck's stack
Remember you!                                #Push 111 ('o') to Puck's stack

You big big big big big cat!                 #Set Puck to 32 (' ')
Puck:You is the sum of I twice twice you!    #Set Ajax to 32+12=44 (',')
Speak thy!                                   #Print ','
Ajax:Remember the sum of twice I a pig!      #Push 2*44-1=87 ('W') to Puck's stack
Scene V:.Ajax:Speak thy!Recall!Let us Scene V!  #Print and pop repeatedly until Puck's stack is empty (', World!')

Euphoria, 23 bytes

puts(1,"Hello, World!")

The (1, parameter tells the puts function to send the output to STDOUT, and there is no carriage return or EOL character for this one line program. This program will work as-is on both RDS Euphoria (v3.1.1 - last commercial version) and OpenEuphoria (v4.1 - current opensource version). The code omits the "optional trailing newline" (per the challenge rules) or else it would be two characters longer (adding n after the !).

I am surprised that no one had added Euphoria to this challenge before now but I am glad that I could as I really like this powerful little language. Since no one added it to this list after more than 2 years I am thinking that maybe CodeGolfers never heard of Euphoria? I am not sure if it is okay to do this here but what follows is a very short description of the language for context. If this is not okay I apologize in advance. Also, where would such information be appropriate? Is there a "directory" of languages post somewhere in the site?

Euphoria was released in 1995 (back in the days of DOS and Windows 3.1) with only two data types: the atom (each contains a single number) and the sequence (essentially a dynamically-sized array of zero or more atoms). Two other types (the integer and the object) were added in recent years to help with efficiency of execution. One of the most interesting things that attracted me to this language long ago besides its remarkably uncomplicated structure is that it runs incredibly fast for an interpreted language. Also it has engines that run on Windows, Linux, and Mac OSX so user code is cross-platform.

PS: It seems as of the time of this posting that the original RDS website linked above is down due to hosting problems after 20 years with the same host. It is unclear when (or if) it will come back up. However the rather extensive library of user created programs for the language is archived here if anyone is wanting good sample code to explore the language.

Attache, 21 bytes

Print!"Hello, World!"

Try it online!

Shakespeare Programming Language, 926 835 bytes

Thanks to @JoKing for -91!

CW'd. At present, the only SPL answer is completely ungolfed and has been so despite comments from last June, so I thought I'd post the RosetTIO answer (with modifications). I couldn't figure out the original author (perhaps this GH user? Who's that on SE?); if this is your work, I'll happily delete (or ask a mod to transfer post ownership and un-CW or something).

a.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:You big big big cat!Puck:You is the sum of I the square of I!Speak mind!You is the sum of you twice twice I!Ajax:You is the sum of a big cat a cat!Puck:You is the difference between you I!Speak mind!You is the sum of the sum of you I a big big cat!Speak mind!Speak mind!You is the sum of you I!Speak mind!Ajax:You big big big big big cat!You is the sum of the sum of you a big big big cat a big big cat!Speak mind!You big big big big big cat!Speak mind!You is the sum of the difference between I you a big big big cat!Speak mind!You is the sum of a big cat a cat!Puck:Speak mind!You is the sum of you I!Speak mind!You is the difference between you twice I!Speak mind!You is the sum of you a big big big pig!Speak mind!You is the sum of a cat a big big big big big cat!Speak mind!

Try it online! 46 warnings, but it does what it needs to do and sounds like Shakespeare^{[citation needed]}. Yay.

I wrote none of this; I merely removed from the RosetTIO program some unnecessary stuff. I outgolfed nothing (just shortened), so this is not eligible for that one bounty.

Changes

• [Exeunt] at the end removed
• Linebreaks removed
• thy in Speak thy mind! removed
• as big as in You is as big as removed
• and removed
• myself and thyself replaced with I and you, respectively

Jstx, 2 bytes

₧P

Try it online!

MachineCode, 68 62 bytes

e80d00000048656c6c6f2c20576f726c6421596a015b6a0d5a6a0458cd80c3

Credit to ceilingcat for finding this (and for the language inspiration). Try it online!

Here's a hacky version that isn't true machine code but works with my language.

MachineCode, 54 bytes

e80d00000H656c6c6f2c20576f726c6421596a1[6adZ6a4Xcd80c3

Abuses the current compiler's parser. Try it online!

Meq, 145 111 bytes

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

^{Thanks Steadybox for saving 34 bytes}

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!

R16K1S60, 42 40 bytes

Program:

C301 000D 0001 5180 2C20 A539 0008 5100 C589 00FF 4701 0003 1000 4865 6C6C 6F2C 2057 6F72 6C64 2100

Source:

[C301 000D] mov sp,hello ;set the stack pointer to the start of the message
[0001     ] dw 1 ;do nothing + skip next instruction
loop:
    [5180] send 0,cx ;output cx (skipped the first time)
    [2C20] pop bx ;read a value into register bx
    [A539 0008] shr bx,cx,8 ;copy bx into cx, shift bx 8 bits to the right
    [5100] send 0,bx ;output bx
    [C589 00FF] @flags and cx,0xFF ;get the lower 8 bits of cx
[4701 0003] jnz loop ;repeat if cx is not 0
[1000] hlt ;end

hello:
    [4865 6C6C 6F2C 2057 6F72 6C64 2100] db "Hello, World!" ;byte data

PHP (on a standard Apache Server, result needing to target STDOUT), 30 27 Bytes

<?php die("Hello, World!");

Note: this is not to detract form earlier PHP example relied on an option assuming PHP wasn't being used as a webserver and abusing the HTML-effect outside of ?php tags to have an answer that was just "Hello, World!"

That said, that solution made some non-standard server assumptions which aren't common with PHP. So I'm presenting an alternative that assumes a normal server layout, but still needs to go to STDOUT. This is not to detract from the previous posters example, but to present one in a different setting with different constraints.

Note: originally thought using

<?php fwrite(STDOUT,"Hello, World!"); ?> 

would be the only way, but then realized the die (normally used killing the script with an error) outputted to STDOUT and didn't use extra variables.

Updated: Cut off a few bytes recalling that "die" wont' bother with anything after itself, so didn't need the closing ?>.

Note: Worth noting, that if shorttags were on with a PHP5 server, could drop down 3 more bytes to 24 bytes with

<? die("Hello World!"); 

However, I was specifically going a standard server, and shortags are now off by default making a server with them on no longer standard.

Example (courtesy of Scrooble): Try It Online!

Brain-Flak, 144 138 bytes

((((((((((((()()){}){}){}){}()))){}{}())([][]){})[][])[[]]())[((()[]){}){}])([()[]](([]([](([][]([](()[][]){})))[]{}[])[[]])))(([][][]){})

Try it online!

The product of my code from the Text to Brain-Flak challenge. Beats the previous answer by 4 bytes! Wheat Wizard has since updated to beat mine by 2. And my code has produced a 140 byte solution (which I've golfed a further 2 bytes off).

Explanation coming as soon as I understand it myself...

How It Works:

Note that Brain-Flak is a stack based language which outputs the stack on exit. This means the text has to pushed to the stack in reverse.

((((((((((((()()){}){}){}){}()))){}{}())([][]){})[][])[[]]())[((()[]){}){}])

This first part pushes "World!". This part is actually near identical to Wheat Wizard's answer, and has the same byte count.

( Pushing "W"
 ( "o"
  ( "r"
   ( "l"
    ( "d"
     ( "!"
      (((((
           (()()) Push 2
          {}) Pop the 2 to push 4
         {}) Pop the 4 to push 8
        {}) Pop the 8 to push 16
       {}()) Pop the 16 and create a 1 to push 33 ("!")
      )){}{}()) Create two copies of 33 and pop them to push 99 and a 1 to push 100 ("d")
      ([][]) Push the stack height (2) twice to the stack
     {}) Pop the 4 and push 8 + 100 = 108, ("l")
    [][] Add the stack height (3) twice to the current value
   ) Push 108 + 3*2 = 114 ("r")
  [[]]() Add negative stack height (4) and 1 to the current value
 ) Push 114 + (-4) + 1 = 111 ("o")
[ Subtract
 (
  (()[]) Push stack height (5) + 1
 {}) Pop the 6 to create 12
 {} Pop the 12 to create 24
]) Push 111 - 24 = 87 ("W")

This part pushes "ello, "

([()[]](([]([](([][]([](()[][]){})))[]{}[])[[]])))

( "e"
 [()[]] Save negative stack height (6) and 1 for later (-7)
 ( "l"
  ( "l"
   [] Save stack height (6) for later
   ( "o"
    [] Save stack height (6) again
    (( ","
      [][] Save stack height (6) twice (12)
      ( " "
       [] Save stack height (6)
       (()[][]){} Push 1 + stack height (6)*2 = 13 and double it = 26
      ) 26 + 6 = 32 (" ")
     ) 32 + 12 = 44 (",")
    )[]{}[] Add the stack height (9), pop the 44 and add the stack height again (8)
   ) 44 + 9 + 44 + 8 + 6 (saved) = 111 ("o")
  [[]] Subtract stack height (9)
 )) Push 111 - 9 + 6 (saved) = 108 ("l") twice
) Push 107 - 7 = 100 ("e")

And finally (([][][]){}) pushes "H" by adding the stack height (12) three times and doubling it.

Atari Logo, 21 bytes

Code:

PRINT [HELLO, WORLD!]

Result:

Dirty, 16 bytes

'Hello, World!'‼

Try it online!

QUARK, 46 bytes

33 100^8+^6+^3−87 32 44 111^3−^^7−72›I

Sets up the numbers in reverse order, with quick number twiddling used for the lowercase characters, as they are quite close together.

ALPHA, 36 bytes

ALPHA is a palindomic alphabetical esoteric programming language made by me and caird. Thought it would be fun to write an answer here.

ALPHA is made of mirrored alphabetical "Containers" that perform programming commands.

KMDHello World!DMK

Explanation:

K - Start line container
M - Start print container
D - Start string container
Hello World!
D - End string container
M - End print container
K - End line container

This lang is WIP. If you want to fix bugs, fork the interpreter, or contribute to completing the interpreter, Go to ALPHA's repository.

DipDup, 15 bytes

[Hello, World!]

Try it online!

Fueue,  44  42 41 40 bytes

Thanks to Ørjan Johansen for saving 2 bytes.

72:108)<101[44+-6:114)32[100 33H]87]:111

Try it online!

Explanation

Fueue is, as the name suggests, a queue-based language, which is a lot more mindboggling than it sounds (although a lot of that is due to the fact that the program and the data reside in the same queue).

Here is a breakdown of the program's execution (there are no negative integer literals in Fueue, so there's no syntax for them; I'll be representing the minus sign as _ to distinguish it from the negation command -):

Cmd    Explanation               Queue
72     Print 'H'.                :108)<101[44+-6:114)32[100 33H]87]:111
:108   Duplicate 108.            )<101[44+-6:114)32[100 33H]87]:111 108 108
)      Inactive.                 <101[44+-6:114)32[100 33H]87]:111 108 108)
<      Inactive.                 101[44+-6:114)32[100 33H]87]:111 108 108)<
101    Print 'e'.                [44+-6:114)32[100 33H]87]:111 108 108)<
[...]  Inactive.                 :111 108 108)<[44+-6:114)32[100 33H]87]
:111   Duplicate 111.            108 108)<[44+-6:114)32[100 33H]87]111 111
108    Print 'l'.                108)<[44+-6:114)32[100 33H]87]111 111
108    Print 'l'.                )<[44+-6:114)32[100 33H]87]111 111
)      Inactive.                 <[44+-6:114)32[100 33H]87]111 111)
<      Append to block.          111)[44+-6:114)32[100 33H]87 111]
111    Print 'o'.                )[44+-6:114)32[100 33H]87 111]
)      Deblock.                  44+-6:114)32[100 33H]87 111
44     Print ','.                +-6:114)32[100 33H]87 111
+      Inactive.                 -6:114)32[100 33H]87 111+
-      Negate 6.                 :114)32[100 33H]87 111+_6
:      Duplicate 114.            )32[100 33H]87 111+_6 114 114
)      Inactive.                 32[100 33H]87 111+_6 114 114)
32     Print ' '.                [100 33H]87 111+_6 114 114)
[...]  Inactive.                 87 111+_6 114 114)[100 33H]
87     Print 'W'.                111+_6 114 114)[100 33H]
111    Print 'o'.                +_6 114 114)[100 33H]
+      Add -6 and 114.           114)[100 33H]108
114    Print 'r'.                )[100 33H]108
)      Deblock.                  108 100 33H
108    Print 'l'.                100 33H
100    Print 'd'.                33H
33     Print '!'.                H
H      Halt the program.

I guess the more interesting question is how on earth did we get here. I started from the basic "Hello, World!":

72 101 108 108 111 44 32 87 111 114 108 100 33H

My primary goal was to get rid of the duplicate 108 for ll, since Fueue has a duplication command. So the naive thing to try is this:

72 101:108 111 44 32 87 111 114 108 100 33H

The problem is that now the 108 doesn't get printed when its duplicated: every command in Fueue puts the result at the end of the queue. So after printing He, and duplicating the 108 we'd end up with this queue:

111 44 32 87 111 114 108 100 33H108 108

Which would just print o, World! and then halt the program, dropping the ll completely.

So we need to delay the execution of everything from 111 to H until after we had time to print the ll. To delay a piece of code by one cycle through the queue, we can wrap it in a block and "unblock" it:

72 101:108)[111 44 32 87 111 114 108 100 33H]

This works! It prints He, then duplicates the 108, then puts the entire rest of the code after the double 108 so we have this queue now:

108 108 111 44 32 87 111 114 108 100 33H

Which is exactly what we want. But we can save one more byte: since the 108 don't get printed immediately, we're free to move the 72 and 101 around in the program: they're going to be printed in the first cycle through the queue no matter what and the 108s are going to end up after them. So by moving the 101 to the end of the program, we can avoid the space between the two numbers.

At this point, we've got my initial 44-byte solution. But I wanted to get rid of the duplicate 111 as well, which seems kinda possible since one of them is now at the start of the block and we've got swap commands. So the first idea is to split up our block around the 111 and add in a duplicate and swap:

72:108~[44 32 87]:111)[114 108 100 33H]101

Of course, this doesn't quite work. There's a couple of problems here: a) we've got no deblock command for the first block. b) The swap happens on the first cycle through the queue, so it actually swaps the block with the duplication wreaking all sorts of havoc. What we really want is to duplicate the 111, then swap the block between the two numbers, but then we also want to deblock that before printing the second 111. That last part is an issue, because if we don't deblock the block the first time around, the 111 is going to printed on the second cycle (before the block can be executed), but if we do deblock it immediately, we can't swap it between the two numbers as a single unit.

The trick is to use the "append" command instead of swap. Instead of trying to get from here:

[44 32 87]111 111

to here:

111 44 32 87 111

We are going to go here instead:

111[44 32 87 111]

By appending the first copy of 111 into the block, and making use of the automatic move to the end of the queue, we hit two birds with one stone: we've moved the , W characters in between the two os and we've ensured that the second 111 can't be printed before the other characters get deblocked. So the basic idea now looks something like this:

72:108<[44 32 87]:111)[114 108 100 33H]101

There's still an issue: the < should happen on the second cycle, because we need the duplication to happen first. We could go with the )[<] technique we used for the 44-byte solution, but we can also delay it by moving the101between it and its argument (because numbers are not a valid first argument for<, the<` will be inactive on the first cyle). We also still need a deblock command for the first block:

72:108)<101[44 32 87]:111)[114 108 100 33H]

Now we're talking. On the first cycle, ) has nothing to deblock so it just moves to the end. Likewise, < has nothing to append we have time to duplicate the 111. On the second cycle, ) still has nothing to deblock, and < appends one copy of the 111 to the block, whereas the other one gets printed. On the third cycle, ) can finally deblock [44 32 87 111], so that they get printed on the fourth cycle. Woohoo, we got Hello, Wo!

But wait: what about the second block? In the current code, it gets deblocked immediately in the first cycle so it would already be executed on the second cycle, printing rld! and terminating the program way too early. The trick is to move it into the first block. That way, it can't possibly be deblocked or executed before those other characters are printed:

72:108)<101[44 32 87)[114 108 100 33H]]:111

We're at 43 bytes now, but we can save two more. This is similar to how we saved the space in the original solution: it doesn't matter where the three numbers inside the outer block appear, because they are going to be printed on the first cycle regardless of where they are. So we can move the ) and the inner block between the numbers to avoid the spaces again:

72:108)<101[44)32[114 108 100 33H]87]:111

This does in fact delay the program by one cycle (because the ) can't deblock the inner block on the first cycle of the outer block), but it doesn't affect the program's result.

The final byte is saved with a bit of arithmetic, courtesy of Ørjan Johansen, to compute the 108 from the 114. The actual code to do so is fairly simple: +-6:114. We make a copy of the 114, we negated a 6 and then add them together to get 108. Since -6 is not a negative literal, but a command applied to a 6, this computation takes two cycles. Thankfully, the : delays the 114 as well, so this just works out. We also now need to remove this from the inner block, so that we have enough time for these two cycles to go through before the d! is printed:

72:108)<101[44+-6:114)32[100 33H]87]:111

MachineCode on x86_64, 125 bytes

4889f8c60748c6470165c647036cc647026cc647046fc647052cc6470620c6470757c647086fc6470972c6470a6cc6470b64c6470c21c6470d00c3
sbrk()

Requires string output via the s flag. Try it online!

This language works like so:

• The first line is machine code. This is translated to a C function.
• The second line is C code. It specifies the arguments to the function created in line 1.
• A command-line argument specifies how the function's return value is used.

So, the machine code is equivalent to:

char *a(char *s) {
    s[0]='H'; s[1]='e'; s[2]=s[3]='l'; s[4]='o'; s[5]=','; s[6]=' '; s[7]='W'; s[8]='o'; s[9]='r'; s[10]='l'; s[11]='d'; s[12]='!'; s[13]=0;
    return s;
}

I generated the machine code via my C lambda script.

Reflections, 41 bytes

_Hello, World!;#_#_#_#_#_#_#_#_#_#_#_#_#_

Test it!

Explanation:

1. The _ at (0|0) pushes my source to the stack.
2. Hello, World! consists of no-ops
3. ; pops the first character.
4. 13 times #_:
   1. # redefines (0|0)
   2. _ at (1|0) prints a character

Dreaderef, 42 bytes

"

??	?r?

0"-1"Hello, World!n"

Try it online! This file contains unprintables. Hexdump:

00000000: 2201 1004 013f 0704 3f09 3f07 5c72 063f  "....?..?.?.r.?
00000010: 0201 1510 0130 222d 3122 4865 6c6c 6f2c  .....0"-1"Hello,
00000020: 2057 6f72 6c64 215c 6e22                  World!n"

There already is a Dreaderef submission, but this uses a different approach (looping through memory rather than printing out each character directly).

Ungolfed:

CODE.
; Dereference the string pointer
0.  deref 16 4
; End the program if the value pointed to is zero
3.  deref ? 7
6.  bool ? 9
9.  ? 7 13 ; Black magic
12. chro ?
; Increment the string pointer
14. add 1 21 16
; Go back to the beginning
18. deref 100 -1

DATA.
21. "Hello, World!n"

Brat, 17 bytes

p "Hello, World!"

Try it online!

Pepe, 122 120 bytes

Pepe is my brand new programming language, which is horrible.

reeEeeEeeereeEEeeEeErEeEEeEEeereeereeeREeEEeEEEEReeereeeEeEEeereeeEeeeeereeEeEeEEEReeereeEEEeeEereeereeEEeeEeereeeEeeeeE

Try it online!

There might be shorter solutions, but that's not task for my brain .-.

That's why I'd offer a 50 100 bounty to anyone who can make it shorter, if it's possible. I don't really believe it is, but maybe you can change my mind?

This solution is quite simple, but better to explain it ungolfed and commented:

reeEeeEeee   # H > print H
reeEEeeEeE   # e > print e
rEeEEeEEee   # l > push l to r
reee reee    #     print it twice
REeEEeEEEE   # o > push o to R
Reee         #     print it
reeeEeEEee   # , > print ,
reeeEeeeee   #   > print a space
reeEeEeEEE   # W > print W
Reee         # o > print active value in R (o)
reeEEEeeEe   # r > print r
reee         # l > print active value in r (l)
reeEEeeEee   # d > print d
reeeEeeeeE   # ! > print !

The first line prints Hello, and a space, the second prints World!. Most of this program are character functions, ex. reeEeeEeee which prints H. By letter:

• r - Stack r
• e - Print
• eEeeEeee - 01001000 (72), the ASCII character for H

As said, most of the program consists of similar commands, but, to golf it a bit, in first occurrence of l, I replaced the first e with E, so instead of printing, it pushed the charcode to the stack. Thanks to this, we can later print l using reee, the command for printing. Edit: Now, I've done the same with o, thanks to the existence of the second stack (notice the R letter).

Min, 20 bytes

"Hello, World!" puts

Stax, 8 bytes

èï┬▀↨╩4G

Run and debug online!

Explanation

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

VSL, 35 33 bytes

Saved 2 bytes thanks to @ASCII-Only

fn main(){print("Hello, World!")}

Try it online!

Okay after over one year development, the day has come where I can post this :D

There is a print("Hello, World!") function but this is shorter. As I seperate libc and libvsl this will probably have to switch over to print but for now this is the shortest.

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

print: "Hello, World!"

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

AlphaBeta, 68 bytes

kjjjggDLeaCLcbbbCLLaaaCLjjjggDLjhhDLsFihhDLCLaaaCLdaaaaCLdaaCLsFiiDL

Try it online!

Felix, 21 bytes

print"Hello, World!";

Try it online!

Somebody linked to this language on PPCG and I thought it was interesting. In the interest of getting to know the language, I thought I'd write some programs in it.

The Felix docs all use print$ x instead of print x because print is a procedure and not a keyword, so use of the Haskell-style low-precedence application operator $ allows a slightly more natural syntax (compare print (1 + foo(5)); with print$ 1 + foo(5);. I'm not sure I agree completely with this, but it's just a convention and as I'm on PPCG I can break it without feeling guilty.

print is Felix's function to output something, with no trailing newline.

Crayon, 16 Bytes

"Hello, World!"q

Try it online!

Momema, 63 bytes

0-9*072*0101*0108*0108*0111*044*032*087*0111*0114*0108*0100*033

Try it online!

This is a golfed version of the Hello World program given by TIO. The only difference is that we store the value -9 (the cell which is memory-mapped for character-based I/O) in cell 0, and then use *0 (the value of cell 0) instead of -9 everywhere. This wouldn't save bytes except that Momema will parse a leading 0 on a string literal as a separate number, so you can write e.g. *0108 instead of -9 108. This saves a byte for every write.

As hinted above, the program consists of a series of writes of various codepoints to -9 (the address which is memory-mapped to perform character-based I/O). In ungolfed form, it looks like:

0   -9
*0  72
*0  101
*0  108
*0  108
*0  111
*0  44
*0  32
*0  87
*0  111
*0  114
*0  108
*0  100
*0  33

Forked, 42 bytes

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

Try it online!

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.

R16K1S60 Assembly, 56 Bytes

a:
mov bx, .b
.l:
mov ax, [bx]
send 4, ax
add bx, 1
cmp bx, .c
jne .l
.h:
hlt
jmp .h

.b: dw "Hello, World!"
.c: dw 14

Writes output to screen peripheral the R16K1S60 in ASCII. Runs on The Powder Toy save 2012356. (See link in header for info)

Note: How exactly should this be scored? I'm assuming just score the size of the ASM.

NEUPL, 14 bytes

"!dlrow ,olleH

Try it online

Explanation:

"!dlrow ,olleH
"               Begin pushing characters to the stack.
 !              Push the character "!" to the stack.
  d             Push the character "d" to the stack.
   l            Push the character "l" to the stack.
    r           Push the character "r" to the stack.
     o          Push the character "o" to the stack.
      w         Push the character "w" to the stack.
                Push the character " " to the stack.
        ,       Push the character "," to the stack.
         o      Push the character "o" to the stack.
          l     Push the character "l" to the stack.
           l    Push the character "l" to the stack.
            e   Push the character "e" to the stack.
             H  Push the character "H" to the stack.
                Implicitly stop pushing characters to the stack.
                Implicitly pop and print each character in the stack.

Ook!, 1426 bytes

Ook! is a joke esoteric programming language created by David Morgan-Mar. It is identical to Brainfuck, except that the instructions are changed into Orangutan words. It represents the first, although unfortunately not the last, in a long line of trivial Brainfuck command substitutions. As such, it is a member of the TrivialBrainfuckSubstitution family of programming languages.

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

17, 71

777{44 $ 5g $ 66 : : $ $ 69 : $ 1f $ 52 $ $ 6c $ $ 5f $ 1g $ a $ 0 @}

Explantation:

Pushes ascii values for Hello World!(in base 17). Then store 17 at 0, to make it exit by relying on the fact that if it tries to pop at number and the stack is empty it return 17 to save two characters.

Rust, 34 bytes

fn main(){print!("Hello, World!")}

Short, Sweet, and simple.

I do not believe it's possible to make this program any smaller. If someone does, congratulations.

Hexagony, 30 29 bytes

H;_e;r;2l.;P.QW;l/P1;@;0d;o;

Try it online!

Source laid out:

    H ; _ e
   ; r ; 2 l
  . ; P . Q W
 ; l / P 1 ; @
  ; 0 d ;  o
   ; . . . .
    . . . .

One more byte off!

Here's a crappy gif of the program in action.

Given there's 2 nops inside the program itself, I'm confidant this can be golfed by at least one more byte. I'm willing to offer a bounty for a smaller version.

Old version:

H;e;r;0Pld;P_1;l;;o;Q;W;$2@

Try it online!

Source laid out:

    H ; e ;
   r ; 0 P l
  d ; P _ 1 ;
 l ; ; o ; Q 
  ; W  ; $ 2
   @  . . .
    . . . .

Reuses the same tricks as Martin Ender's answer, i.e Q2 printed is the comma, P0 is the space, P1 is the bang, but manages to be 2 bytes shorter through clever mirroring to reuse several ;s and the o.

Explanation:

Here's a coloured Hexagony grid to show the non-branching path that the pointer takes:

The executing code, ignoring mirrors, is:

H;e;l;;o;Q2;P0;W;d$;o;$2r;0Pl;Wd;P1;@

Filtering out the skipped instructions and the literals that are overwritten by other literals, we are left with:

H;e;l;;o;Q2;P0;W;o;r;l;d;P1;@

Which simply prints "Hello, World!"

After a few attempts, I gave up on a size 3 Hexagony answer. You need a minimum of 12 instructions out of 19 reserved for string literals, along with three ;s for printing and one @ for ending the program. This leaves only 3 spaces for IP management and memory management, provided you find the optimal path that reuses both the o and the l. From all this, I'll rule that a size 3 answer is impossible, though I'll give a sizable bounty to anyone who proves me wrong.

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!

MY-BASIC, 20 bytes

Print"Hello, World!"

Try it online!

Yabasic, 16 bytes

May there always be BASIC in this world!

?"Hello, World!"

Try it online!

uBASIC, 17 bytes

0?"Hello, World!"

Try it online!

Commentator, 197 bytes

         {-        -}!/*{-{-           {-         -}!  /*       /*/*   /*-}-}#    {-   -}!/*{- e#-}///*{-e#-}//{-#  -}!{-# e#-}///*{-{-/*   /*{-e#-}//   /*-}-}             /*#   {-            -}!/*

Try it online!

I'm genuinely surprised it took me this long to make a somewhat golfed Hello, World! program in Commentator.

095, 16 bytes

'Hello, World!'s

First answer in my attempt at making a programming language! Pushes Hello, World! to the stack and then prints.

ELVM-IR, 116 68 66 65 bytes

.data
.string"Hello, World!"load B,A
putc B
add A,1jne 0,A,13exit

Thanks to @ASCII-only for golfing off 48 50 51 bytes!

Try it online!

Background

Running the above program with eli <file> interprets it, but elc -<target> <file> is where the real magic happens: it translates ELVM-IR source code to any of the supported backends!

Try it online!

The ELVM toolchain also supports compiling (a subset of) C and its standard library to ELVM-IR.

Try it online!

Pain-Flak, 152 bytes

)))))}{}{)))}{))(}{((((])][][][([(])()()([((]][[()()()(])}{][][)][(][([())(]][][][][][[))(]][[)][][)][][][][))(}{}{))))(}{)}{)}{))()()()((((((((((((}><{

This is a trivial modification of @HeebyJeebyMan's “Hello, World!” in Brain-Flak. They also discovered a slightly different solution with the same length shortly before I golfed mine down to this byte count.

Try it online!

How it works

Pain-Flak is transpiled to Brain-Flak as follows.

• Let the Pain-Flak source code be S.
• Transliterate S, replacing all opening brackets with their closing counterparts and viceversa. Call the result T.
• Reverse S character by character. Call the result R.
• The Brain-Flak source code is T || R, where || symbolizes concatenation.

For the Pain-Flak program in this answer, transpilation yields the following Brain-Flak program.

((((({}{}((({}((){}))))[([][][])])[()()()]))[[]])()()()[({}[][]([])[])])(()[[][][][][]](()[[]]([][]([][][][]((){}{}((((){}({}({}(()()()())))))))))))
{<>}
{<>}
(((((((((((()()()()){}){}){}()))){}{}())[][][][])[][])[[]]())[[][][][][]]())([([]([])[][]{})]()()()([[]](([()()()]([([][][])](((({}()){}))){}{})))))

Newlines have been inserted for "readability". The programs works as follows.

• Line 1 pushes garbage on the first stack.

• {<>} on line 2 switches stacks until the top of the stack is non-zero.

  This switches to the second stack.

• {<>} does the same. Since the top of the second stack is 0, we stay on the second stack.

• Line 4 is just @HeebyJeebyMan's “Hello, World!” in Brain-Flak, which never switches stacks and is, therefore, unaffected by the garbage on the first stack.

Broccoli, 23 bytes:

(print "Hello, World!")

Broccoli is a random language I ran across whilst recording the PPCG podcast. I promised that I would post an answer in it, so here it is. The better way of writing this (in 28 bytes) would be:

(print "Hello, World!" endl)

But since the newline is optional, this works.

Clean, 30 bytes

module m
Start="Hello, World!"

Try it online!

TIO link is 3 bytes longer to match TIOs file name: main.icl

Triangularity, 71 49 bytes

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

Try it online!

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

Old version

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

Try it online!

Ace, 1 byte

H

Try it online!

This is a golfing language I am currently in the process of making, so I thought I'd post it here. It's based on Aceto. I wasn't quite satisfied with what Aceto had to offer but I really liked using it so I decided I'd make my own language and include more builtins and NOT RUN THE IP ON A HILBERT CURVE. It currently has ~30 commands and I am improving it every day. I plan to get it officially on TIO by August 2018

Pyt, 40 39 bytes

89*2ᴇ⁺Đ7+ĐĐ3+5⬡⁻2⁵9²6+Đ4!+Đ3+Đ6-2ᴇĐ₃áƇǰ

Explanation:

89*                                                  Pushes 72 ('H')
   2ᴇ⁺                                               Pushes 101 ('e')
      Đ7+                                            Duplicates 101, then adds 7 ('l')
         Đ                                           Duplicates 108 ('l')
           Đ3+                                       Duplicates 108, then adds 3 ('o')
              5⬡⁻                                   Pushes 44 (',')
                  2⁵                                 Pushes 32 (' ')
                    9²6+                             Pushes 87 ('W')
                        Đ4!+                         Duplicates 87, then adds 24 ('o')
                            Đ3+                      Duplicates 111, then adds 3 ('r')
                               Đ6-                   Duplicates 114, then subtracts 6 ('l')
                                  2ᴇ                 Pushes 100 ('d')
                                    Đ₃               Duplicates 100, then divides by 3 (Python 2-style integer division)
                                      á              Replaces the stack with an array containing the stack's contents
                                       Ƈ             Cast to unicode characters
                                        ǰ            Join strings
                                                     Implicit print

Try it online!

face, 41 bytes

(Hello, World!
)$*m%*7%+%%%,c'$,ioow%$%o

Explanation:

(...)   comment, skipped over by interpreter but used to embed string in source
$*     assign $ to a pointer to the source code and * to a pointer to the IP
m%*     malloc space for %, a variable which will be used to store the length
7%+%%%  set % to 14 in a roundabout way (% = 7, % += %), the length of the string
,c'$,i  step into char mode to increment $, setting the start of the string
oo      set o to stdout
w%$%o   fwrite(str, 14, stdout), throwing the return value into %

Try it online!

Assembunny, 100 bytes

out 72
out 101
out 108
out 108
out 111
out 44
out 32
out 119
out 111
out 114
out 108
out 100
out 33

I think I could have miscounted.

Explanation

This code uses the extra signal generator instruction out x from day 25 for output.

This is the output:

  Dec  72 101 108 108 111  44  32 119 111 114 108 100  33
  Hex  48  65  6C  6C  6F  2C  20  77  6F  72  6C  64  21
ASCII   H   e   l   l   o   ,       w   o   r   l   d   !

SNOBOL4 (CSNOBOL4), 29 28 bytes

 OUTPUT ='Hello, World!'
END

Try it online!

Thanks to Ørjan Johansen for saving a byte!

LLVM IR, 110 bytes

@s=global[13x i8]c"Hello, World!"declare i8@puts([13x i8]*)define i8@main(){call i8@puts([13x i8]*@s)ret i8 0}

Try it online!

Whispers, 29 bytes

> "Hello, World!"
>> Output 1

Try it online!

An even newer language than Verbosity.

How it works

> "Hello, World!" - Line 1
>                 - Yield a constant value, which is...
  "Hello, World!" -   The string "Hello, World!"

>> Output 1       - Line 2
>>                - Replace numbers with line references
   Output         - Output the value...
          1       - ...on line 1

Verbosity, 382 bytes

Include<Integer>
Include<MetaFunctions>
Include<Output>
Include<String>
Integer:DefineVariable<o;1>
Output:DefineVariable<P;0>
String:DefineVariable<s;"Hello, World!">
String:RedefineVariable<s;String:RemoveCharactersFromStart<s;o>>
String:RedefineVariable<s;String:TakeFirstCharacters<s;o>>
Output:DisplayAsText<P;s>
DefineMain<> [
MetaFunctions:ExecuteScript<MetaFunctions@FILE>
]

Try it online!

Ungolfed

Include<Integer>
Include<MetaFunctions>
Include<Output>
Include<String>

Integer:DefineVariable<one; 1>
Output:DefineVariable<STDOUT; 0>
String:DefineVariable<string; "Hello, World!">

String:RedefineVariable<string; String:RemoveCharactersFromStart<string; one>>
String:RedefineVariable<string; String:TakeFirstCharacters<string; one>>

Output:DisplayAsText<STDOUT; string>

DefineMain<> [
	MetaFunctions:ExecuteScript<MetaFunctions@FILE>
]

Try it online!

I proudly present yet another language: Verbosity. Who needs to be good at code golfs, when you have a language like this?

CRPL and its sister language PRPL, 21 bytes

Bit of an obscure language, but the official tutorial doesn't contain a Hello World program so this at least is worth something.

"Hello, World!" Trace

"Hello, World!" pushes the string Hello, World! to the stack, and Trace pops an item from the stack and add it to the trace log, the closest thing the language has to SDTOUT or a console.

Alas, for this language is too obscure for Dennis's gadget; however, I have written the following interpreter in JS with all the complexity needed for this demo. I may one day make it support more.

var code = '"Hello, world!" Trace';
var stack = [];
var vars = Object.create(null);

var literals = [];
code = code.replace(/"(.*?)"/g, (m, $1) => 'lit' + [literals.length, literals.push($1)][0]).split(/s/);

for (var token of code) {
    if (token.match(/^lit(d+)$/)) {
        stack.push(literals[token.slice(3)]);
    } else if (token.match(/^-?d+.?d*/)) {
        stack.push(+token);
    } else if (token.startsWith('<-')) {
        stack.push(vars[token.slice(2)]);
    } else if (token.startsWith('->')) {
        vars['v' + token.slice(2)] = stack.pop();
    } else {
        switch(token) {
            case 'Trace5':
                console.log(stack.pop());
            case 'Trace4':
                console.log(stack.pop());
            case 'Trace3':
                console.log(stack.pop());
            case 'Trace2':
                console.log(stack.pop());
            case 'Trace':
                console.log(stack.pop());
                break;
            default:
                throw new Error(token + 'is not implemented.');
        }
    }
}

AArch64 machine language Linux, 48 45 bytes

 0: d2800020 mov x0, #0x1       ; stdout is fd=1
 4: d28001a2 mov x2, #0xd       ; length of string
 8: 94000001 bl  c              ; put addr of pc to x30
 c: 910053c1 add x1, x30, #0x14 ; put addr of string to x1
10: d2800808 mov x8, #0x40      ; select write() syscall
14: d4000001 svc #0x0           ; syscall
18: d2800bc8 mov x8, #0x5e      ; select exit() syscall
1c: d4000001 svc #0x0           ; syscall
20: 6c6c6548 "Hello, World!"
    77202c6f
    646c726f
          21

To try it out on an AArch64 Linux machine or Android device with Termux, compile and run the following C program. You may need to pass the -zexecstack argument to the compiler.

const char main[]=" x80xd2xa21x80xd21x94xc1x53x91bbx80xd21xd4xc8vx80xd21xd4Hello, World!"

Flipbit, 148 134 129 bytes

^>>>^>>>.^<<^<^<<^>>>>>.^<<<^>>>..^<^>.[<]<?>^>^>>.<<^<^>>>.<<<^>>^>^>^.<<<^<^<^>>>>>.[<]?^>>>^>.<<<<?>^>^>>.<<<^>>>.<<<<<?>>>>^.

Try it online!

-14 bytes thanks to Aaron Miller

-5 bytes thanks to Bubbler

How it works

Flipbit uses an infinite tape, consisting of either a 1 or a 0 per cell. The way it outputs is getting all previous elements in the tape, converting that from binary, then indexing into Unicode.

Excel VBA, 15 Bytes

Anonymous VBE immediate window function that takes no input and outputs Hello, World! to the VBE immediate window.

?"Hello, World!

Brain-Flak, 448 bytes

((()()()()()()()()()()())({}){})
((()()()()()()()()()())({})({})({})({})({})({})({})({}){})
(([][][][][][])({})({})({})({})({})({})({}){})
(([][][][][][]())({})({})({})({}){})
(([][][]()())({})({})({})({})({})({}){}[()])
(([][][][])({})({})({})({}){}[()])
(([]()())({})({}){})
(([]()()()())({})({}){})
(([]()()())({})({})({})({})({})({})({})({}){}())
((([]()()())({})({})({})({})({})({})({}){}))
(([][][()()])({})({})({}){}())
([]()())(({})({})({})({}){}()())

Try it online!

Newlines added for clarity

Spaced, 91 bytes

(q="Helo, Wrd!")[1]+q[3]+q[5]+q[5]+q[7]+q[9]+q[9+2]+q[9+4]+q[7]+q[9+6]+q[5]+q[9+8]+q[9+9+1]

Try it online!

Symbolic Python, 200 bytes

Managed to cut down 16 bytes from my original example on the wiki. Note that the unprintable on line two is xc2x8d.

This can definitely be shorter, but it took me long enough. I'll come back to it another time.

__=-~(_==_)
__=`_`[~__]+`_>_`[__::__]+`''`[-__::~__**__]
_=_==_
___='%'+__[-_]
__,_=___+__[-~_]+__[_]*-~_+__[_>_]+', '+___+__[_>_]+`_`[_]+__[-~_-_]+__[~_]+'!',-~-~_
___=_*_<<_
_=__%(___,___+_*-~-~_)

Try it online!

Archway2, 182 bytes

                   
 /
  >++>+++>+++>+<<<<-/>+>+>->+<<<<<->>.>---.+++++++..+++.>>++++.------------.<-.<.+++.------.--------.>>+.
      
++++>
++++++++/                         /

Try it online!

This program was derived from the Hello, World! program that I wrote for TIO. I realized that the code not inside the sub-loops can be aligned with the code inside the sub-loops removing some redundant direction changing. Unrolling the loop consisting of only a < to <<<< saves many bytes by not requiring the spaces to support the positioning of the reflectors. Flipping the main loop to go around the bottom of the program instead of the top allows the first few instructions of the main loop to be put on its own line while still being reachable from the start of the program. This lets us move the sub-loop closer to the edge of the program saving bytes.

Рапира (Rapira), 57 26 22 bytes

OUTPUT:"Hello, World!"

Try it online!

Or, more appropriately, (33 bytes):

ВЫВОД:"Привет Мир!"

ADJUST, 281 bytes

 ;I-      &  e$      &  m-        &  g2Ph$      &  a2$      &  n$      &  e2+-      &  g2Ph$      &  OPh$      &  m-      &  e-      &  n-
}     AgR};      AgR};      A=AgR};         AgR};       AgR};      AgR};        AgR};         AgR};        AgR};      AgR};      AgR};      AC

Try it online!

Diagonal }; turn IP right. I-, e$, m-, etc. create ascii code in the accumulator and push it on both stacks. A print char. gR};& move IP to the first line. = swap stacks. C exit.

Nhohnhehr, 181 bytes

+-----------+
|$010010000|
|1100101011|
|0110001101|
|1000110111|
|1001011000|
|0100000010|
|1011101101|
|1110111001|
|0011011000|
|1100100001|
|00001  @  |
+-----------+

Try it online!

Bitwise, 149 bytes

MOV 1 &1 &1
OUT &72 1
OUT &101 1
OUT &108 1
OUT &108 1
OUT &111 1
OUT &44 1
OUT &32 1
OUT &87 1
OUT &111 1
OUT &114 1
OUT &108 1
OUT &100 1
OUT &33 1

Pretty simple - just prints integer literals (&x) as ASCII characters. MOV 1 &1 &1 sets the 1st register to 1, so that each line can save 1 byte (using 1 instead of &1). The second variable to OUT is not optional. If the second variable (register/frame register/literal) is true, the character will be printed, otherwise it will not.

Try it online!

Wierd (John's), 432 421 302 289 256 225 197 181 bytes

-*******************           !dlroW ,olleH
 *
 R*   *    *     *
 E*  **    **   *
 T*  **    **  *
 U ***   ***  ****
 R   *  *  *      *
 N  *    *  ********
    *  ****
 0   **

Try it online!

Background

Wierd's workspace determines both code and data. While each character sets the workspace's cell to its code point (missing characters are treated as spaces, which have code point 32), the code is defined by a particle that starts in the upper left corner and moves along a wire. This wire is also defined by the characters: non-spaces form wires, spaces separate these wires. Instructions are encoded into the kind of turns the particle takes.

At the beginning, the upper left corner holds the number 45, which is the x-coordinate of the cell to the right of !dlrow ,olleH. Each loop through the asterisks that form the main wire decrements that coordinate, prints the character, then prints the character it points to. After all 13 characters have been printed, the upper left corner becomes a space, causing the particle to traverse RETURN 0 instead of the main wire. Once 0 is reached, the particle can no longer move; the program ends.

For the first 12 iterations, the particle moves as follows.

<style>body,html,svg{display:block;height:100%;margin:0;padding:0;}</style>
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 210 105"><path d="M 20 80 L 20 100" fill="none" stroke="#FFC0C0" stroke-width="3"/><path d="M 20 8.5 L 20 80" fill="none" stroke="#C00000" stroke-width="3"/><path d="M 20 98.5 L 20 101.5" fill="none" stroke="#C00000" stroke-width="3"/><path d="M 180 30 L 200 10 L 199 10" fill="none" stroke="#C0C0C0" stroke-width="3"/><path d="M 200 10 L 10 10 L 30 30 L 30 50 L 40 60 L 60 60 L 70 50 L 70 30 L 60 40 L 60 70 L 50 80 L 50 90 L 60 100 L 70 100 L 80 90 L 110 90 L 90 70 L 100 60 L 120 60 L 130 50 L 130 40 L 120 30 L 120 70 L 130 80 L 200 80 L 180 60 L 150 60 L 180 30" fill="none" stroke="#000000" stroke-width="3"/><path d="M 10 10 L 30 30 L 30 50 L 40 60 L 60 60 L 70 50 L 70 30 L 60 40 L 60 70 L 50 80 L 50 90 L 60 100 L 70 100 L 80 90 L 110 90 L 90 70 L 100 60 L 120 60 L 130 50 L 130 40 L 120 30 L 120 70 L 130 80 L 200 80 L 180 60 L 150 60 L 180 30 L 200 10 Z" fill="none" id="move-loop"/><circle r="4" fill="#00C0C0"><animateMotion dur="10s" repeatCount="indefinite"><mpath xlink:href="#move-loop"/></animateMotion></circle></svg>

However, during the thirteenth and last iteration, the upper left corner if removed, so the particle moves down the red wire instead.

Code

As illustrated in the Stack Snippet, the particle takes the following left turns on the main wire.

• 315° Subtract. Nothing is done, since the stack is empty.

  This turn, like the other no-ops, is made solely to save space.

• 45° Push 1. STACK: [1]

• 45° Push 1. STACK: [1 1]

• 45° Push 1. STACK: [1 1 1]

• 45° Push 1. STACK: [1 1 1 1]

• 135° Pop the stack. Since the popped element is 1, pop two more values (1 1) and push the code point of the character at those coordinates. STACK: [1 n]

  Initially, the character at (1, 1) is -, so n = 45.

• 45° Push 1. STACK: [1 n 1]

• 315° Subtract. STACK: [1 (n-1)]

• 45° Push 1. STACK: [1 (n-1) 1]

• 45° Push 1. STACK: [1 (n-1) 1 1]

• 45° Push 1. STACK: [1 (n-1) 1 1 1]

• 45° Push 1. STACK: [1 (n-1) 1 1 1 1]

• 315° Subtract. STACK: [1 (n-1) 1 1 0]

• 135° Pop the stack. Since the popped element is 0, pop two more values (1 1) and store the next value on the stack (n-1) at those coordinates. STACK: [1]

  During the first run, the upper left corner changes from - (45) to , (44).

  During the thirteenth and last run, the upper left corner changes from ! (33) to space (32), essentially cutting the wire.

• 270° Pop the stack. Since the popped element is 1, continue. STACK: []

• 315° Subtract. Nothing is done, since the stack is empty.

• 45° Push 1. STACK: [1]

• 45° Push 1. STACK: [1 1]

• 45° Push 1. STACK: [1 1 1]

• 135° Pop the stack. Since the popped element is 1, pop two more values (1 1) and push the code point of the character at those coordinates. STACK: [(n-1)]

• 45° Push 1. STACK: [(n-1) 1]

• 45° Push 1. STACK: [(n-1) 1 1]

• 135° Pop the stack. Since the popped element is 1, pop two more values (1 (n-1)) and push the code point of the character at those coordinates. STACK: [c]

  During the first run, this retrieves the character at (44, 1), which is H.

• 45° Push 1.

• 225° Pop the stack. Since the popped element is 1, pop the next item and print it to STDOUT. STACK: []

• 180° Jump to the rightmost star on the first line.

• 135° Get/set. Nothing is done, since the stack is empty.

  After this turn in the upper left corner, the particle starts over.

BrainFlump, 362 bytes

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++:..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.;.--------.-------------------------------------------------------------------.

Try it online!

Should be shorter once we fix loops, but that's it for now.

LNUSP, 360 353 bytes

-6 bytes thanks to ASCII-only

001 . !.!
002 !    !
001 *  !!
033 +
001 *
100 +
001 *
108 +
001 *
114 +
001 *
111 +
001 *
087 +
001 *
032 +
001 *
044 +
001 *
111 +
001 *
108 +
001 *
108 +
001 *
101 +
001 *
057 +
015 +                    ?...?@             !
001 *                   ?@ .  ?
001 !                   . +.  *
001  .                  ?  !  ?
001   !..................?.@.?

Ungolfed version:

001 . !.!                  .OUTPUT          .EXIT
001  .   !                 .                .
001 ! .  !                 .                .
001 .  !!                  .                .
001 *                      .                .
033 + !                    .                .
001 *                      .                .  
100 + d                    .                .
001 *                      .                .
108 + l                    .                .
001 *                      .                .
114 + r                    .                .
001 *                      .                .
111 + o                    .                .
001 *                      .                .
087 + W                    .                .
001 *                      .                .
032 +                      .                .
001 *                      .                .
044 + ,                    .                .
001 *                      .                .
111 + o                    .                .
001 *                      .                .
108 + l                    .                .
001 *                      .                .
108 + l                    .                .
001 *                      .                .
101 + e                    .                .
001 *                      .                .
072 + H                    .                .
001 *                      .                !
001 .                      .               .
001 .                      .              .
001 .                      .             .
001 .                      .            .
001 !                      .           .
001  .                     .          .
001   .                    .         .
001    .                   .        .
001     .                @ .       .
001      .                +.      .
001       .                !     .
001        .               .    .
001         .           ?.....?@
001          .         ?   .   ?
001           .        .   .   *
001            .       ?   .   ?
001             !.......?..@..?

Note that TIO LNUSP does not require newline at the end of file.
Some explanations are here. Can be golfed 4 bytes more, I didn't do it for aesthetic purpose.

Try it online

PATH, 113 bytes

/++}+++++++}+++++}<$+++++++<
+}++}++++++{{{{{-^}++.}+++.+++++++..+++.}++.}++++.}+++.{{{.+++.------.--------.}}+.

Try it online!

Implicit, 15 14 bytes

«Hello, World!

Pretty simple. « opens a string, implicit closing ». Implicit output.

Try it online!

Deorst, 15 bytes

'Hello, World!'

Try it online!

Yay for implicit output!

Recursiva, 15 14 bytes

"Hello, World!

Try it online!

This can also be done by explicitly using Por Print operator:

Recursiva, 16 bytes

P"Hello, World!"

Try it online!

JoshScript, 596 bytes

JOSHJoshJoshJoshJoshJoshJoshJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshJoshJOSHJOshJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOshJOshJOSHJOSHJOSHJOshjosHjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshJOshjosHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOshjoshjoshjoshjoshjoshjoshjoshjoshjoshjoshJoshJoshjoshJOshJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOshJOSHJOSHJOSHJOshjoshjoshjoshjoshjoshjoshJOshjoshjoshjoshjoshjoshjoshjoshjoshJOshjosHjosHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOSHJOsh

JoshScript is an esoteric language that is made up entirely of joshes.

JoshScript is pretty easy to learn, below is the usage of JoshScript v1.01

JOSH increases the value by 1

josh decreases the value by 1

Josh multiplies the value by 2

josH divides the value by 2 and rounds down to the nearest integer

JOsh outputs the current value

joSH takes input and sets the value to the ascii repr. of the char

im not josh-obsessed i promise

Java, 61 bytes

enum H{H;{System.out.print("Hello, World!");System.exit(0);}}

This is valid in both Java 5 and Java 6. This won't work in Java 4 or earlier (because enum didn't exist) and will not work in Java 7 or after (because the bypass^[1] was "fixed").

enum H {                               // An enum is basically a class.
  H;                                   // Static initialization of the mandatory instance, invoking the default constructor.
                                       // Happens before the existence check of "main"-method.
                                       // No constructor means default constructor in Java.
  {                                    // Instance initialization block.
                                       // Executed in each constructor call.
    System.out.print("Hello, World!"); // duh!
    System.exit(0);                    // Exit before the JVM complains that no main method is found.
                                       // (and before it writes on stderr)
  }
}

Rough equivalence in Java as usually written

The above code is roughly equivalent to the following one.

class HelloWorld {
  public final static HelloWorld INSTANCE;
  static {
    INSTANCE = new HelloWorld();
  }
  public HelloWorld() {
    System.out.print("Hello, World!");
    System.exit(0);
  }
}

Proof of correctness

$ java -version
java version "1.6.0_45"
Java(TM) SE Runtime Environment (build 1.6.0_45-b06)
Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode)

$ javac H.java

$ java H
Hello, World!
$

1: The bypass consists of the static execution of code when the class is being linked. Before Java 7, the main-method-containing class was no exception to the static initialization code. Afterwards, static initialization was delayed until the main method would actually be found.

Monkeys, 484 460 455 448 bytes

7 RIGHT
7 RIGHT
7 RIGHT
7 RIGHT
7 UP
5 DOWN
5 RIGHT
4 DOWN
7 TEACH
7 BOND
4 UP
7 BOND
7 TEACH
7 TEACH
6 YELL
4 TEACH
4 TEACH
7 FIGHT
5 TEACH
6 YELL
7 TEACH
7 TEACH
5 FIGHT
6 YELL
6 YELL
7 TEACH
5 FIGHT
6 YELL
7 EGO
4 TEACH
5 TEACH
6 YELL
4 FIGHT
7 TEACH
6 YELL
4 TEACH
4 TEACH
4 DOWN
7 TEACH
4 UP
4 TEACH
5 FIGHT
6 YELL
4 TEACH
7 TEACH
6 YELL
7 TEACH
5 FIGHT
6 YELL
7 FIGHT
5 FIGHT
5 FIGHT
6 YELL
7 FIGHT
7 FIGHT
6 YELL
7 EGO
7 TEACH
7 TEACH
6 YELL

Try it online!

How it works

Monkeys consists internally of a 10x10 grid containing 7 monkeys (and 14 bananas we won't use). The grid initially looks as follows.

..!1.!....
.......2!.
.........!
.3.!......
.......!..
.!....!...
..5.!4....
....6...!.
......!...
.7......!.

All monkeys initially have a value of 0. Moving a monkey UP, DOWN, LEFT, or RIGHT increments its value by 1, unless the target square is adjacent (horizontally, vertically, or diagonally) to another monkey.

In addition, any monkey can modify all adjacent monkeys' values with TEACH (adding the "teacher's" value to adjacent monkeys' values), FIGHT (subtracting), BOND (multiplying), and EGO (dividing).

First,

7 RIGHT
7 RIGHT
7 RIGHT
7 RIGHT
7 UP
5 DOWN
5 RIGHT

moves monkeys 5 and 7 to their final positions. This sets 5's value to 1 and 7's value to 4. The grid now looks as follows.

..!1.!....
.......2!.
.........!
.3.!......
.......!..
.!....!...
....!4....
...56...!.
.....7!...
.!......!.

Now,

4 DOWN
7 TEACH
7 BOND
4 UP

monkey 4 moves down (and is now adjacent to 7), monkey 7 adds its value (4) to monkeys 4 and 6, monkey 7 multiplies 4's and 6's values by 4, then 4 moves back to its place. The monkeys' values are now as follows.

 5:  1
 7:  4
 4: 16

 6: 16

From now on, we'll mostly use monkeys 5, 7, and 4 to add or subtract 1, 4, or 16 to/from monkey 6's value. Making monkey 6 YELL prints its value as a character.

If we represent monkey 6's value with v, the remainder of the program looks as follows in pseudo-code.

7 BOND   v *=  4 // v ==  64
7 TEACH  v +=  4 // v ==  68
7 TEACH  v +=  4 // v ==  72 == 'H'
6 YELL   putchar(v)
4 TEACH  v += 16 // v ==  88
4 TEACH  v += 16 // v == 104
7 FIGHT  v -=  4 // v == 100
5 TEACH  v +=  1 // v == 101 == 'e'
6 YELL   putchar(v)
7 TEACH  v +=  4 // v == 105
7 TEACH  v +=  4 // v == 109
5 FIGHT  v -=  1 // v == 108 == 'l'
6 YELL   putchar(v)
6 YELL   putchar(v)
7 TEACH  v +=  4 // v == 112
5 FIGHT  v -=  1 // v == 111 == 'o'
6 YELL   putchar(v)
7 EGO    v /=  4 // v ==  27
4 TEACH  v += 16 // v ==  43
5 TEACH  v +=  1 // v ==  44 == ','
6 YELL   putchar(v)
4 FIGHT  v -= 16 // v ==  28
7 TEACH  v +=  4 // v ==  32 == ' '
6 YELL   putchar(v)
4 TEACH  v += 16 // v ==  48
4 TEACH  v += 16 // v ==  64
4 DOWN   The next operation will affect monkey 4 as well.
7 TEACH  v +=  4 // v ==  68
4 UP     Monkey 4's value changed from 16 to 20.
4 TEACH  v += 20 // v ==  88
5 FIGHT  v -=  1 // v ==  87 == 'W'
6 YELL   putchar(v)
4 TEACH  v += 20 // v == 107
7 TEACH  v +=  4 // v == 111 == 'o'
6 YELL   putchar(v)
7 TEACH  v +=  4 // v == 115
5 FIGHT  v -=  1 // v == 114 == 'r'
6 YELL   putchar(v)
7 FIGHT  v -=  4 // v == 110
5 FIGHT  v -=  1 // v == 109
5 FIGHT  v -=  1 // v == 108
6 YELL   putchar(v)
7 FIGHT  v -=  4 // v == 104
7 FIGHT  v -=  4 // v == 100 == 'd'
6 YELL   putchar(v)
7 EGO    v /=  4 // v ==  25
7 TEACH  v +=  4 // v ==  29
7 TEACH  v +=  4 // v ==  33 == '!'
6 YELL   putchar(v)

Dreaderef, 31 bytes

This file contains unprintables. Here is a reversible hexdump created with xxd:

00000000: 2206 4806 6506 6c06 6c06 6f06 2c06 2006  ".H.e.l.l.o.,. .
00000010: 5706 6f06 7206 6c06 6406 2106 5c6e 22    W.o.r.l.d.!.n"

Try it online!

How does it work?

The reason this file is so unreadable is because it makes use of string literals to golf the code. The preprocessor expands string literals into their respective character values. The actual numbers this represents are:

6 72 6 101 6 108 6 108 6 111 6 44 6 32 6 87 6 111 6 114 6 108 6 100 6 33 6 10

6 is the command associated with chro (char output). So this code looks like this:

chro 72
chro 101
chro 108
chro 108
chro 111
chro 44
chro 32
chro 87
chro 111
chro 114
chro 108
chro 100
chro 33
chro 10

DOBELA, 214 bytes

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

With comments:

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

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

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

Try it online

Magic Number, 174 bytes

0010000033001000010000100001080010000114001000011100100000870010000032001000004400100001110010000108001000010800100001010010000072006006006006006006006006006006006006006006

Magic Number is a simple human-writable stack-based esolang where the source code consists of a single positive integer. The decimal digits are read from most significant to least significant.

The only two commands used here are 0010xxxxxx, which pushes the non-negative integer xxxxxx onto the stack, and 006, which pops the stack and prints the character with that character code. The program pushes the numerical value of the characters in "Hello, World!" onto the stack in reverse order and prints them all. Branching is fairly expensive, so I feel this is probably optimal.

AsciiDots, 18 bytes

.-$"Hello, World!"

Try it online!

Windows Portable Executable (PE), 1175 bytes

By using the following Assembly code instead of C code (which inevitable imports unecessary libraries and whatnot), we can cut down the executable size from 261591 bytes (compiled C answer) to a measily 1536 bytes.

extern ExitProcess, GetStdHandle, WriteConsoleA

section .n
    msg db "Hello, World!",10

; <entry point>
Start:
    ; GetStdHandle(in A1)
    push -11           ; A1 - STD_OUTPUT_HANDLE
    call GetStdHandle  ; Puts in eax

    ; WriteConsole(in A1, in A2, in A3, out A4, reserved A5 )
    push 0             ; A5 - Don't care (reserved argument)
                       ; A4 - Don't care ("number of chars written")
    push 14            ; A3 - Length ("number of chars to write")
    push msg           ; A2 - String (buffer pointer)
    push eax           ; A1 - Console output handle (from GetStdHandle)
    call WriteConsoleA

    ; ExitProcess(in A1)
    push 0             ; A1 - Exit code
    call ExitProcess

However, that is still way too large. So I installed HxD, a hex editor, and went on to try and remove unecessary parts.

Apparently, Windows' executables are filled with padding (hex indication) for no apparent reason. So I removed the tailing block of zeroes at the end of the file, messed around a bit, and managed to cut it down to 1175 bytes. Here's the pastebin hexdump of the executable.

Unfortunately, at my every attempt to remove the other paddings (0x1A8-0x1FF, 0x22B-0x3FF), the program would simply not run. I've been doing this for a few days to no success. Thus, I'm posting this beaten, at the still staggering 1KB of size.

I am sure this can be golfed even further, so if anyone manages to cut down the size, feel free to edit this answer or perhaps even post another one.

As a bonus, this executable also works on DOS.

MY, 60 bytes

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

MY IS ON TIO!!

How?

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

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

Lost, 57 54 45 43 38 37 36 bytes

roW"\ dl
<@+1(
lo, /"Hel
%<<<?<<<

Try it online!

Lost is a 2 dimensional language in which the start location and direction are entirely random. As you might imagine it is rather difficult to write deterministic programs in lost. However the language has a couple of design features that allow for deterministic programs to be written.

This draws on JoKing's 38 byte solution but is significantly more bizarre.

Explanation

This is a bit to messy to explain in a satisfactory way.

Set, 123 bytes

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

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

Try it online!

axo, 22 bytes

"!dlroW ,olleeH">[(#<

I'm not sure why I had to put a double e in there. But hey, it works.

Try it online!

Numberwang, 77 bytes

69696969696969693696969623673363316969696968359533059595636969663633563583193

Try it online!

Just incrementing and decrementing the pointer by certain amounts.

Shtriped, 239 bytes

e n
e b
i b
+ x y
 +
  i x
  d y
  +
 +
 d x
0
 + b b b
1
 + b n n
 0
z x
 d x
 z x
D
 1
 s n
 z n n
 z b b
 i b
Y
 0
 0
Z
 1
 Y
 Y
B
 0
 1
1
Z
1
Y
1
Y
D
B
B
1
0
Z
Y
D
B
1
Y
B
0
Z
D
1
B
B
Y
1
0
D
Y
1
1
Y
B
Z
D
B
Y
1
0
Z
Y
D
B
1
1
1
1
B
0
D

Try it online!

This Hello, World! in Shtriped terminates somewhat quickly, since it doesn't encode the entire string in one number.

Pyramid Scheme, 857 bytes

  ^      ^      ^     ^      ^      ^      ^      ^      ^      ^      ^      ^      ^
 /     /     /    /     /     /     /     /     /     /     /     /     / 
/out  /out  /out /out  /out  /out  /out  /out  /out  /out  /out  /out  /out
-----^ -----^ -----^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^-----
    /     /     /     /     /     /     /     /     /     /     /     / 
   /chr  /chr  /chr  /chr  /chr  /chr  /chr  /chr  /chr  /chr  /chr  /chr
  ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^----- ^-----
 /     /     /     /     /     /     /     /     /     /     /     / 
/72   /101  /108  /111  /44   /32   /87   /111  /114  /108  /100  /33 
-----  -----  -----  -----  -----  -----  -----  -----  -----  -----  -----  -----

Try it online!

Wow. At least it's kinda clear how this works...

ZT, 199 bytes

The ZT programming language is quite romantic: it features little data couples (Romeos & Juliets). ZT program flow is diagonal and commands are defined only by program flow.

The webpage is at:

• http://web.archive.org/web/20060202003431/http://www.winterbergs.de/software/zte.htm

It has a link to is an interpreter at:

• http://web.archive.org/web/20051222231734/http://www.winterbergs.de:80/software/ztinte.php

But that interpreter is broken and doesn't do jumps correctly. The website also has a link to a self extracting archive containing the documentation, the interpreter and some examples:

• http://web.archive.org/web/20060202003431/http://www.winterbergs.de/software/ExtractZT.exe

And that interpreter works so that's the one you need to use to test this.

I am not too confident that this is the smallest possible Hello World but it is much smaller than the one published on the website. If you have comments for golfing it please let me know.

48<>ZT<>ZT<>...>
<<ZT<>ZT<>ZT.<06
ZT<>ZT<>6F<>6C<<
<<ZT<>ZT<>ZT><03
ZT<>ZT<>20<>72<<
<>ZT<>ZT<>ZT><05
...>65<>6F<>57<<
.>ZT<>ZT<>ZT><05
....64<>6C<>2C<<
....<>ZT<>ZT><05
........21>.6C<
........<...>

ABCD, 390 bytes

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAADDAAADBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBDBBBBBBBBBBBBDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAADAAADBBBBBBDBBBBBBBBDBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBDBBBBBBBBBBBBBBBBBBBBBBBD

AAHH! This is a weird esolang.

SE, 66 61 bytes

array h is [H e l l o , _space W o r l d !] end
do>with h end

T h i s _space e s o l a n g _space i s _space b a d _space a t _space o u t p u t ! (This esolang is bad at output!)

SE stands for self-explanitory, not Stack Exchange :(.

Subterra, 30 bytes

"Hello, World!"w[0>]{bct1-}

Caker, 294 bytes

ωΩθΩθθΩθΩθθθΘΩθθΩθθΩθΩθΩθΘθθΩθΩθθΩθθΘΩθθΩθΩθθΩθθΘΩθθΩθΩθθθθΘθΩθΩθθΩθθΘΩθΩθθθθθΘΩθΩθΩθΩθΩθθθΘθθΩθΩθθθθΘθθθΩθθΩθΩθΘΩθθΩθΩθθΩθθΘΩθθΩθθΩθΩθθΘΩθΩθθθθΩθΘ

Looks like alot of zeros...

HTML & JS (w/ jQuery), 85 bytes

<b><script src="//code.jquery.com/jquery.min.js"><script>$("b").html("Hello, World!")

Emoji, 23 24 bytes

?Hello, World!?➡ 

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

Emmental, 68 bytes

#0#10#33#100#108#114#111#119#32#44#111#108#108#101#72...............

From the esolangs.org page.

,,,, 14 bytes

"Hello, World!

I finally added unclosed strings to ,,,. Took me long enough.

Positron, 21 bytes

print@"Hello, World!"

Try it online!

Just to get this out there :)

Ly, 19 18 bytes

"!dlroW ,olleH"[o]

First submission in my new language!

Aheui, 147 144 bytes

발따밤따빠받나파빠밣다빠밦다빠받타밢밢따밦다밤밣따밦밦따빠밣다파받따빠받다파빠빠밠타밣밢따아멓희

Lean Mean Bean Machine, 55 bytes

OOOOOOOOOOOOO
"""""""""""""
Hello, World!
!!!!!!!!!!!!!

I think this is the shortest.

Here's a somewhat more entertaining alternative approach in 96 bytes:

OOOOOOOOOO
"""
Hel
!!!""""
  !o, W
   !!!!



   !   "
       r
       !""
  !     d!
        !!

This one only sets 1 marble to each letter, and re-uses the l and o marbles, much less golfy, but more true to the spirit of the language.

Sqirrel - Peter, 903 bytes

A couple notes about my golfing:

• The examples have punctuation at the end of sentences but the spec doesn't say that it should be there so I left it off.
• The spec says The request consists firstly of the text "I wish I had a " then is followed by a thing. and list of the variable-things you can use: ... an Apple which is inconsistent so I used "I wish I had a Apple" because it is shorter.
• The spec says Here is [nr] [thing][s] Set the var to NR. Add an 's' if needed and even though the examples use Fishes the only ones that should be valid are Fish and Fishs and I chose Fish because I don't think it needs to be plural and it is shorter.
• There is an exit command but the spec doesn't say what happens if the flow reaches the end of the text so I am assuming the program ends and I didn't use the exit command.

Here is my attempt:

I wish I had a Fish
Here is 72 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 101 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Apple
Here is 108 Apples
I wish I had a Apple
Now everyone has it
I wish I had a Apple
Now everyone has it
I wish I had a Forrest
Here is 111 Forrests
I wish I had a Forrest
Now everyone has it
I wish I had a Fish
Here is 44 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 32 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 87 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Forrest
Now everyone has it
I wish I had a Fish
Here is 114 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Apple
Now everyone has it
I wish I had a Fish
Here is 100 Fish
I wish I had a Fish
Now everyone has it
I wish I had a Fish
Here is 33 Fish
I wish I had a Fish
Now everyone has it

nouse, 321 bytes

I can't figure out from the spec how to specify operands in Line Noise syntax. If anyone knows please comment.

Here is the Assembly syntax version:

cut 0,72,write 0,paste 0
cut 0,101,write 0,paste 0
cut 0,108,write 0,write 0,paste 0
cut 0,111,write 0,paste 0
cut 0,44,write 0,paste 0
cut 0,32,write 0,paste 0
cut 0,87,write 0,paste 0
cut 0,111,write 0,paste 0
cut 0,114,write 0,paste 0
cut 0,108,write 0,paste 0
cut 0,100,write 0,paste 0
cut 0,33,write 0,paste 0
swap 0

@, 2 bytes

The language is made of a tree of function calls. Each character (with some exceptions) represents a function that may take as many or few arguments as it likes. Arguments are then read from directly after it in the code.

ħ

The ħ builtin returns the string "Hello, World!"

Foam, 17 bytes

<'|Hello, World!|

<' grabs the next token from the source code an outputs it with a trailing newline. The next token is Hello, World! (It is wrapped in bars so that the space can be added without it being treated like another token.

cQuents, 15 bytes

Hello, World!?0

Try it online!

Explanation

Hello, World!    Literal "Hello, World!"
             ?   Mode ? (query)
              0  Necessary for interpreter
                 Because there is no input for query mode, only print literals

Husk, 8 bytes

¨H◄⁰,ω]!

Try it online!

Husk got compressed strings!

A dictionary of common n-grams for n from 1 to 9 was built using a procedure based on Huffman coding, taking frequencies of n-grams from http://norvig.com/mayzner.html. All printable ASCII characters plus newline were forced to have 1-byte encodings with codes corresponding to themselves, while newlines were encoded with ¶. N-grams that occurr frequently at the start of words also have variants with title-case and with a leading space/newline; n-grams that occurr frequently at the end of words also have variants with a trailing space/newline.

Some optimizations were performed on the resulting dictionary: for instance, the 5-gram "Hello" was removed from the dictionary since it had been encoded with three bytes, while the 4-gram "ello" is encoded with two bytes, so we can simply encode "H"+"ello" for a total of 3 bytes.

After the Huffman tree was built, codes were reassigned (mantaining their length unchanged) such that the encoded words could in some way recall their respective plaintext: most compression systems ignore this and as such their results are completely obscure to the human reader, while in this case I'm sure that most of you could guess what H◄⁰,ω]! means even if it was not presented inside this challenge. In particular, ◄⁰ encodes "ello", since ◄ stands for l (left), and ⁰ looks like an o, while ω] encodes " World" since ω looks like a w and ] looks like a D (capitalization was ignored for this assignment of codes).

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.

Sad-Flak, 199+3 bytes = 202 bytes

3 bytes for the -A arg. This lang uses a "codepage", where ≤≥ are one byte each (that is, I have a thing that replaces ` and ~ with those chars and runs it)

32
({}≤()≥)
(≤()≥)
99
({}≤()≥)
((<>[≤()≥]))
7
({}≤()≥)
((<>))≤()≥
5
({}≤()≥)
(≤()≥)
109
({}≤()≥)
(<>)(≤()≥)
85
({}≤()≥)
(≤()≥)
30
({}≤()≥)
(≤()≥)
42
({}≤()≥)
({≤()≥})(({()}))({()})(())
70
({}≤()≥)
≤≥

Try it online!

Explanation:

The main idea behind this is that the way Sad-Flak works, you can easily get it to repeat a line a constant number of times.

in Sad-Flak, there is a line pointer. The line pointer starts at the beginning

-> 32
   ({}≤()≥)
   (≤()≥)
   99
   ({}≤()≥)
   ((<>[≤()≥]))
   7
   ({}≤()≥)
   ((<>))≤()≥
   5
   ({}≤()≥)
   (≤()≥)
   109
   ({}≤()≥)
   (<>)(≤()≥)
   85
   ({}≤()≥)
   (≤()≥)
   30
   ({}≤()≥)
   (≤()≥)
   42
   ({}≤()≥)
   ({≤()≥})(({()}))({()})(())
   70
   ({}≤()≥)
   ≤≥

however, the 32 is not actually a command. it is a simple way to express 32 blank lines. I could expand them for the demonstration, but then it would be unreadable. anyway.

So, the line pointer points at the first of 32 blank lines. When the line pointer points at a non-blank line, it will execute that line. when the line pointer points at a blank line, it will execute the first non-blank line after that line. that means we execute ({}≤()≥). What does this line do? This lang is a brainflak derivative, btw, so some of the brackets do the same thing, but not all

(        push...
 {}      pop off the main stack and evaluate to that value, plus
   ≤     jump by the amount inside, evaluate to that value for the purpose of other commands
    ()   1
      ≥
       )

so, this pops off the stack, adds one to it while jumping one forward, then pushes back on the stack. What is jumping? why are we jumping in the middle of a line?

Jumping in Sad-Flak is rather different to most other langs. Jumping does not take immediate effect, but rather moves the line pointer. when the line pointer is moved, nothing happens until the current line is finished executing. when it is finished, we see which line the line pointer points at, and execute that. If the line pointer didn't get moved, the same line gets executed again, and again, until it gets moved. however, all lines in this program either are blank, or they jump or halt. So, this line moves the line pointer one forward and increments top of stack.

What is the line pointer pointing at now? it's still on a blank line, so it does the same thing again, and again, until it gets to the line that it keeps executing

   32
-> ({}≤()≥)
   (≤()≥)
   99
   ({}≤()≥)
   ((<>[≤()≥]))
   7
   ({}≤()≥)
   ((<>))≤()≥
   5
   ({}≤()≥)
   (≤()≥)
   109
   ({}≤()≥)
   (<>)(≤()≥)
   85
   ({}≤()≥)
   (≤()≥)
   30
   ({}≤()≥)
   (≤()≥)
   42
   ({}≤()≥)
   ({≤()≥})(({()}))({()})(())
   70
   ({}≤()≥)
   ≤≥

Then, it executes it one last time, before moving to the next line. this end up with the charcode of ! on the stack (32 blanks + 1 actual line)

   32
   ({}≤()≥)
-> (≤()≥)
   99
   ({}≤()≥)
   ((<>[≤()≥]))
   7
   ({}≤()≥)
   ((<>))≤()≥
   5
   ({}≤()≥)
   (≤()≥)
   109
   ({}≤()≥)
   (<>)(≤()≥)
   85
   ({}≤()≥)
   (≤()≥)
   30
   ({}≤()≥)
   (≤()≥)
   42
   ({}≤()≥)
   ({≤()≥})(({()}))({()})(())
   70
   ({}≤()≥)
   ≤≥

this line ((≤()≥)) pushes a new 1 to the stack, and moves the line pointer one forward, onto a new blank line, to do basically the same thing as it did before. however it puts charcode of e. and also the next line is this: ((<>[≤()≥])). What is this complex line? well:

((        push twice...
  <>      value popped from stack, and pushed onto the offstack for later retrieval
    [     minus ...
     ≤    (jump but eval to the argument still)
      ()  1
        ≥
         ]
          ))

so, this pops the e off the stack, and replaces it with two ds, while leaving an e on the off stack for later retrieval, and also jumping the line pointer to the next line. we have two, because one will be changed into l, because it saves bytes from pushing a 1 and incrementing it up to the next letter. we don't do this for all of them because it also cost bytes popping and pushing back onto the stack, as well as fitting the jump in there.

from now on, I'm skipping the blank lines and the increment top of stack lines, because this explanation is long enough already.

after adding 8 to yield l

((          push twice...
  <>        a value popped from stack, also pushed to offstack
    ))
      ≤     jump ...
       ()   1
         ≥

add 6 to yield r: this one again: (≤()≥) new value at 111 (o):

(           push...
 <>         popped value, also pushed to offstack.
   )
    (       push...
     ≤      (jump and eval to same as...)
      ()    1
        ≥
         )

so this pushes to the off stack while keeping it on the stack, and pushing another 1 on the stack.

new 87 (W): this again: (≤()≥)

new 32 (space): same again: (≤()≥)

new 44 (,): ({≤()≥})(({()}))({()})(()) woah, what is that? put simply, it is just pushing onto the main stack what we pushed on to the offstack, then a 1 to make into a H:

(             push...
 {            pop from the off stack, evaluate to that multiplied by...
  ≤           jump and eval to...
   ()         1
     ≥
      }
       )         this pushes o

        ((         push twice...
          {        multiply an offstack popped value by...
           ()      1
             }
              ))     this pushes l twice

                (        push...   
                 {       offstack popped value times...
                  ()     1 
                    }
                     )      this pushes e

                      (    push...
                       ()  1
                         )

new 72 (H): ≤≥: this is the halt command and it stops the program

That pushed !dlroW ,olleH char codes, which then gets printed, but backwards because it is a stack. "Hello, World!"

MY, 73 bytes

Here's the hex:

07 24 21 21 28 26
0A 24 21 28 26
0B 24 20 20 28 26
0B 24 20 20 28 26
0B 24 21 28 26
04 24 21 21 21 21 28 26
02 25 28 26
09 24 20 20 20 28 26
0B 24 21 28 26
07 25 21 21 28 26
0B 24 20 20 28 26
0A 24 28 26
02 25 21 28 26

I didn't want to update my old answer, because this one isn't just a simple one-byte solution that uses a builtin.

How it works: Outputs each character by using the few commands I have interpreted:

• Number Literal: 0x00 - 0x0F
• Minus 1: 0x20
• Add 1: 0x21
• Times 10: 0x24
• Times 16: 0x25
• Output: 0x26
• Character value: 0x28

Cubically, 124 123 111 99 78 bytes

^{-11 bytes thanks to TehPers, -12 thanks to language updates, -21 thanks to user202729}

RU+432@6+50-4@6+3-4@6@6+1-00@6-331@6-00@6+4110@6+0000@6+1-00@6-0@6-2+4@6-331@6

Generated via this amazing algorithm.

There is a good explanation of Cubically in this question.

Cubically, the Rubik's Cube Programming Language, is the most complex language I have ever written, or dealt with, for that matter. It entirely comprises of operations on a single 3x3 Rubik's Cube in its memory, and one extra value, the "notepad".

The only way to perform mathematical operations is to take values from a certain cube face and add/subtract/multiply/divide it with the scratch pad value, replacing said value.

For example, performing /0 divides the notepad value by the sum of all integers on the 0-indexed face, or the first face.

The cube starts out initialized like this:

   000
   000
   000
111222333444
111222333444
111222333444
   555
   555
   555

Performing a 90-degree clockwise turn on the right face will make the cube look like this:

   002
   002
   002
111225333044
111225333044
111225333044
   554
   554
   554

Version from TehPers:

Here's a run-down of how the program works: (Note that I have replaced @6 with @ in the code, but changing each instance in the rest of this answer would be too tedious and I need to get back to real life.)

• +53 adds the DOWN face and RIGHT faces into the notepad, in this case, 45 and then 27. This results in 72, the ASCII code for H.
• @6 prints the notepad value as ASCII.
• :2 sets the notepad to the value of the FRONT face (18).
• /1 divides the notepad by the LEFT face (9), resulting in 2.
• +551 Adds the DOWN face (45) twice, then the LEFT face (9). As you can see, without rotating the cube, the faces will contain a total value equal to 9 times the index. For example, face index 5 has a value of 45, face index 1 has a value of 9, and so forth. After rotating the cube, this no longer applies.
• @6 again prints the notepad value, or e.
• :5 sets the notepad to the value of the DOWN face (45).
• +52 adds the DOWN face (45) and the FRONT face (18) to the notepad.
• @66 prints the current notepad value as a character twice. At this point Hell has been printed, which should be good enough for this language. :P
• :3/1 sets the notepad to the value of the RIGHT face (27), then divides the notepad by the value of the LEFT face (9), resulting in 3. Do you see the pattern yet?
• +552 adds 108 to the notepad, or 9*(5+5+2). Remember, if you rotate the cube, then the faces will not necessarily be multiples of 9!
• @6 prints the notepad value as a character, finishing the word "Hello".
• From this point there is nothing interesting. The program follows the pattern of setting the notepad value to whatever c % 9 is (where c is the target character), then adding multiples of 9 to the notepad get to the target character. The faces are not rotated, so this isn't exactly the best showcase program for Cubically, but it's certainly simpler than what could be accomplished with rotating the faces. There may be a shorter way to write this program using rotations, though.

Original (written by hand >.<)

+53@6+1F2L2+0@6L2F2U3R3F1L1+2@66L3F3R1U1B3+0@6:4U1R1+00@6-000@6+50000@6+000000@6+2-000000@6-5+4000@6-00@6/0+00@6:0+0/0+00@6

The above Hello World program uses arbitrary turns that I fiddled with until they got some desired values. Eventually, I got the top face to add up to 4 and made do with that.

Here's a run-down of how the program works:

• +5+3 adds the DOWN face and RIGHT faces into the notepad, in this case, 45 and then 27. This results in 72, the ASCII code for H.
• @6 prints the notepad value as ASCII.
• +1 adds the LEFT face to the notepad value, resulting in 81.
• F2 turns the FRONT face to look like this.
• L2 turns the LEFT face to look like this.
• +0 adds the UP face to the notepad, resulting in 101.
• @6 prints memory as ASCII e.
• L2F2U3R3F1L1 turns the cube to look like this.
• +2 adds the FRONT face to the notepad, resulting in 108. @66 prints as ASCII twice ll. At this point Hell has been printed, which should be good enough for this language. :P
• L3F3R1U1B3 turns the cube to look like this.
• +0 adds the UP face to the notepad (resulting in 111), @6 prints it as ASCII o.
• :4 sets the notepad to the BACK face 36.
• U1R1 turns the cube to look like this. The cube is not turned again 'cause this was about as good of a setup I could get.
• +0+0 adds the UP face to the notepad twice, resulting in 44.
• @6 prints as ASCII ,.
• -000 subtracts 12 from the notepad (32). @6 prints as ASCII .
• From this point there is nothing interesting except messing with the existing faces, particularly the top face (which has a convenient value 4), to print the remaining characters.

Triangular, 66 bytes

8.9,*<>@5,1*6<>-+@7,+3@@+<>@:3_7+,3@-*43@<>*9-@p@3+@_3@-8@-6@<

Try it online!

How it works

Expanded:

          8
         . 9
        , * <
       > @ 5 
      , 1 * 6 <
     > - + @ 7 
    , + 3 @ @ + <
   > @ : 3 _ 7 + 
  , 3 @ - * 4 3 @ <
 > * 9 - @ p @ 3 + 
@ _ 3 @ - 8 @ - 6 @ <

Executed commands, ignoring directional commands:

89*@56*1-+@7+@@3+@:3_7+@4*-@3*9-@p@3+@6-@8-@3_@

Commands used, ignoring directional commands:

• 1 to 9: push the literal value
• +: add
• -: subtract
• *: multiply
• _: divide
• :: duplicate top of stack
• p: pop top of stack
• @: print top of stack as charcode

Triangular is a 2D stack-based language which uses postfix notation.

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

Pyffman 1, 16 bytes

The code contains lots of unprintable characters, so here's a hexdump:

00000000: 78c2 40a6 9a7a 5d51 7d8e 87cf 617d cf3d  [email protected]]Q}...a}.=

To obtain the original source code, put the hexdump in a file and call xxd -r on it.

Small, 1552 bytes

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.

A joke language at https://esolangs.org

Memescript, 820 bytes

what the frick frack backtrack snick snack quarterback diddily dack diddily dack quarterback diddily dack diddily dack backtrack diddily dack backtrack diddily dack biofeedback quarterback diddily dack diddily dack quarterback quarterback diddily dack quarterback diddily dack diddily dack patty wack quarterback diddily dack slack mack frick frack thumbtack snick snack snick snack quarterback diddily dack patty wack sidetrack quarterback diddily dack snick snack patty wack patty wack biofeedback quarterback diddily dack diddily dack sidetrack diddily dack sidetrack quarterback diddily dack diddily dack patty wack quarterback diddily dack patty wack slack mack quarterback diddily dack patty wack crackerjack quarterback diddily dack slack mack frick frack thumbtack snick snack patty wack quarterback diddily dack

Explanation:

what the                     open program
frick frack backtrack        push 10
snick snack quarterback      multiply by 7 (70)
diddily dack diddily dack    add 2 (72)
quarterback diddily dack     print as char ('H')
diddily dack backtrack       add 10 (82)
diddily dack backtrack       add 10 (92)
diddily dack biofeedback     add 9 (101)
quarterback diddily dack     print as char ('e')
diddily dack quarterback     add 7 (108)
quarterback diddily dack     print as char ('l')
quarterback diddily dack     print as char ('l')
diddily dack patty wack      add 3 (111)
quarterback diddily dack     print as char ('o')
slack mack                   pop
frick frack thumbtack        push 11
snick snack snick snack      multiply by 4 (44)
quarterback diddily dack     print as char (',')
patty wack sidetrack         subtract 12 (32)
quarterback diddily dack     print as char (' ')
snick snack patty wack       multiply by 3 (96)
patty wack biofeedback       subtract 9 (87)
quarterback diddily dack     print as char ('W')
diddily dack sidetrack       add 12 (99)
diddily dack sidetrack       add 12 (111)
quarterback diddily dack     print as char ('o')
diddily dack patty wack      add 3 (114)
quarterback diddily dack     print as char ('r')
patty wack slack mack        subtract 6 (108)
quarterback diddily dack     print as char ('l')
patty wack crackerjack       subtract 8 (100)
quarterback diddily dack     print as char ('d')
slack mack                   pop
frick frack thumbtack        push 11
snick snack patty wack       multiply by 3 (33)
quarterback diddily dack     print as char ('!')

Neim, 16 bytes

(Hello, World!)B

Try here

Made possible thanks to (partial) BigInteger support.

Fishing, 25 24 bytes

[+_
|C]`Hello, World!`Ni

It exits with an error.

Fishing, 34 bytes

v+CCCCCCCC^]
  `Hello, 
  N`!dlroW

Without errors.

Add++, 70 20 bytes

D,f,,"Hello, World!"

Try it online!

Simple function, implicit call and return. You can see the revision history for the old version.

Decimal, 48 bytes

13072069076076079044032087079082076068033010D301

This uses only two commands:

• 13 - push a STRING
• 301 - print from stack to output

On the date of posting, Decimal has another Hello World that's a bit more boring:

Hello,13032301World!

According to the README:

Decimal, also called 09D, is an esoteric stack-based programming language that uses the characters 0 through 9 and D. Any other characters in the source code are simply printed.

But spaces and newlines are ignored, because those often fallthrough from comments and commands, adding the necessity for the 13032301. (I need to update the README.)

Casio Basic, 15 Bytes

"Hello, World!"

I think it explaines itself well enough...

Python 1, 20 bytes

print"Hello, World!"

Try it online!

Noether, 16 bytes

"Hello, World!"P

Try it here!

Noether is basically a stack-based, Reverse Polish Notation version of Fourier. Plans for this language include overloaded functions and string functions.

Noether is named after the pioneering mathematician Emmy Noether.

Explanation:

"Hello, World!" - Push the string "Hello, World!" to the stack
P               - Print the item on the top of the stack

COBOL, 65 Bytes

PROGRAM-ID.H.PROCEDURE DIVISION.DISPLAY 'Hello, World!'.STOP RUN.

Just from what I remember. Probably doesn't work but I can't tell since my machines set up to run COBOL are long-gone.

Packed Pyth, 13 bytes

Hexdump:

0000000: 4523 2ecd 9bd6 20af bf96 cc88 40         E#.... .....@

Packed Pyth is Pyth with a 7-bit ASCII encoding.

This Pyth program:

"Hello, World

Gets packed into this Packed Pyth program:

E#.͛� ���̈@

To create the file:

$ echo -n '"Hello, World!' > hello.pyth
$ py ../pyth/packed-pyth.py -p hello.pyth hello.ppyth

To run it:

$ py ../pyth/packed-pyth.py hello.ppyth 
Hello, World!

2Col, 2 bytes

HW

Hooray, another boring answer using a Hello world builtin.

;#

Interpreter provided by @ETHProductions

Read this for a full list of commands.

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

Klein, 48 + 3 + 3 = 54 bytes

89*55+:*:(1+:7+:::(3+:(485*+48*699*+):3+))148*+@

Try it online!

StupidScript, 214 bytes

It's a joke language that I just made. Mark Watney would be proud.

80.5 0.0
80.5 23.0
69.0 103.5
69.0 161.0
80.5 46.0
23.0 0.0
23.0 23.0
46.0 92.0
69.0 57.5
69.0 138.0
69.0 138.0
69.0 172.5
23.0 138.0
23.0 0.0
57.5 80.5
69.0 172.5
80.5 23.0
69.0 138.0
69.0 46.0
23.0 11.5
23.0 23.0

Klein, 16 + 3 = 19 bytes

"Hello, World!"@

• +3 for -A flag
• Also contains a null argument for the topology, I'm not even sure how to score that.

Try it online!

Competing for the bounty.

Klein, 50 + 6 = 56 bytes

+3 bytes due to the -A flag.

+3 bytes for 000 topology (though in my testing, pretty much all valid topoligies work)

89*45:**:(1+:7+::3+:(492+*84*9:*6+):3+6:3**)84*1+@

(Eligible for the bounty) Probably not optimal, but it's a start.

shortC, 26 21 19 16 bytes

AR"Hello, World!

Just to showcase the language.

SASS, 32 bytes?

:after
  content:"Hello, World!"

MY, 1 byte.

Here is the hex:

FF

I'm finally ready to reveal my language. It's still a major WIP, and the undefined byte meaning is temporary (except for maybe 0xFF). I will eventually update this to include a non-hacky solution when MY is able to do that.

Aceto, 19 bytes

Aceto is the coolest programming language because I got it as a birthday present. It is a stack based programming language that makes use of a 2D Hilbert curve grid. Here is Hello World:

o,or
l Wl
le!d
"H"p

OIL, 15 bytes

Hello, World!
4

OIL is a self-modifying turing-machine-like programming language with random access, and weak typing. The first line does nothing, because it's not one of the integers currently defined as commands, so it is just skipped. The second line is a 4, the print command, which takes one argument (the next line) and prints the value at that location. Since the next line doesn't exist, it's uninitialized and defaults to 0, which causes OIL to print the contents of the 0th line, Hello, World!.

Braingolf, 17 bytes

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

"Hello, World!"&@

Explanation:

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

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

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

Explanation:

#!                                 Push the charcode of char '!' to the end of the stack
  ....................             Do this for every character in "Hello, World!" in reverse order
                      @@@@@@@@@@@@@  Pop and print the last element of the stack 13 times

NotQuiteThere, 17 bytes

'Hello, World!'-1

Try it online!

~~~, 2200 bytes

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬¬_~~~~~~~~~~¬~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬~~~~~~~~~~~~~~~~~~~~~~~~¬~~~¬-¬_~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~¬

Yet another brainfuck-esque language. This uses UTF-32 encoding

~ adds one to the value

¬ outputs the value mod 127

- move forward along the tape

_ move back along the tape

;# 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

ASP / VBSCRIPT, 13 bytes

Another boring answer!

Hello, World!

Alice, 19 18 bytes

Thanks to Sp3000 for saving 1 byte.

"&O@!dlroW ,olleH

There should be a carriage return (0x0D) at the end of the program, but browsers don't like those. Consequently, this version is also not testable on TIO. Here is a 19-byte printable-only alternative:

"!dlroW ,olleH"d&O@

Try it online!

Finally introducing my latest language! This works like Hello, World in most Fungeoids, and doesn't really touch upon all the advanced features Alice has:

"&O@!dlroW ,olleH  Push the individual code points of the entire source code
                   except the " to the stack. Remember that there's a 13 at the end.
&                  Repeat the next command 13 times.
O                  Pop 13 characters from the stack and print them.
@                  Terminate the program.

In the 19-byte version, we're pushing the 13 explicitly, using the stack depth command d.

Here is a somewhat more interested 21-byte version, which makes use of Alice's main feature: by moving diagonally, Alice operates in a separate mode (called Ordinal mode), which works with strings instead of integers. However, due to the diagonal movement, it's a bit harder to follow the code:

/oH!lloo /
@""edlr,W

Try it online!

The initial / sends the instruction pointer off southeast, where it will bounce diagonally up and down between the two lines. The / at the end offset the IP's position by one cell so that on the way back, the IP bounces through the other characters. So ignoring those mirrors, the code that actually gets executed is:

"Hello, World!"o@

In Ordinal mode, "Hello, World!" actually pushes an entire string to the stack, o prints that string, and then @ still terminates the program.

Charcoal, 13 bytes

Hello, World!

Charcoal prints the canvas state at the end of execution, and any run of ASCII characters is considered a string, which is implicitly printed to the canvas.

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.

USML, 9 bytes

S0h7cWs8h

Try it online!

Explanation:

S0h7cWs8h
S0h7       # Get characters 0-7 of h ("Hello, world!").
    cW     # Get the character "W"
      s8h  # Get the remaining characters, starting at character 8, of h.

This program is an interesting problem, as it has a command that outputs "Hello, world!" (and an empty program will also do this), but the capitalization is not correct. As a result, we need to take some substrings and add in the correct character.

Turing, 18 bytes

put"Hello, World!"

HODOR, 2384 bytes

Walder
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
HODOR!
Hodor Hodor Hodor
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor
HODOR!
Hodor Hodor Hodor
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor! Hodor!
HODOR!
HODOR!!!

I decided that my NO! answer wasn't long enough so I finished my commemoration of Hodor and spend a while coding this.

Hodor uses an accumulator because he's learning to count and can't remember more than 1 number.

In short (because I'm not doing a line-by-line explanation) these are the main commands:

Walder Hodor hodor hodor hodor Hodor hodor hodor hodor

Hodor Hodor hodor hodor hodor hodor

Hodor! Hodor hodor hodor hodor hodor

HODOR! Hodor hodor hodor hodor hodor hodor hodor

HODOR!!! Hodor Hodor (Hodor hodor hodor)

No, 1185 bytes

NOOOOOOOOOOOOOOO?Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo!Nooooooooooooooooooooooooooooooooo
NOOOOOOOO?yes

Try it online!

No is a line based language, meaning that execution starts on the last line and the other lines are referenced throughout the program. Each line consists of the following:

• A command, in the format of N followed by a number of Os. The number of Os determines which command is meant
• One or more arguments, separated from the command with a ? and from each other with a !. The arguments can be one of four options:
  • N followed by $n$ os. This represents a character with charcode $n$
  • n followed by $n$ os. This represents an integer $n$
  • $m$ ns followed by $n$ .s and $p$ Os. This represents a floating point number with integer part $m$ and a fraction part consisting of $n$ $0$s followed by $p$. For example, nnn.O is $3.01$
  • ye followed by $n$ ss. This references the result found by running line $n$, 1-indexed.

This Hello, World program works by first running the last line:

NOOOOOOOO?yes

8 Os means that this is the output command, so this line outputs the value of line 1, the super long one. Line 1 works by using the „string builder“ command (NOOOOOOOOOOOOOOO or 15 Os) which takes a list of characters and returns them joined as a string. In this case, the characters form the String Hello, World! and so use the charcodes of those letters in order to return characters according to the 1st type of argument as specified above.

√ å ı ¥ ® Ï Ø ¿ , 2 bytes

HW

H  › Push the string "Hello, World!" to the stack
 W › Output the whole stack as Unicode interpretations

Yes it's that basic...

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.

KanyeC, 78 bytes

"A programming language based on the brilliance of Kanye West."

I am the greatest
make her say "Hello, World!"
I still think I am the greatest

Yes, it is essentially just an ArnoldC substitution, but I thought I'd contribute it for the sake of completeness.

Graphic 154 bytes

x=72 printa(x) y=101 printa(y) y+7 y+3 x-28 x-12 x+55 + y-6 y-8 x-54 +
1
2 0 0 13 7 8 9 0
3
4 9 5 6 0 0 0 5 10 11 12
9
9
9
9
9
1 3 3 3 1 1 1 3 3 3 3
9
9
9

There is a trailing newline

This language is based off of a directed graph. The first line is the list of nodes, each consisting of a single command. The following n lines are the links between nodes on the graph.

Explanation

The first line initializes the nodes as 0: x=72 1: printa(x) 2: y=101 3: printa(y) 4: y+7 5: y+3 6: x-28 7: x-12 8: x+55 9: + 10:y-6 11:y-8 12:x-54 13:+

The program starts with a direction value of 0 at node 0.

x=72 go to node 1

Print character represented by x go to node 2

y=101 go to node 3

Print character represented by y go to node 4

Add 7 to y go to node 9

Increment direction by 1 go to node 3

Print character represented by y go to node 9

Increment direction by 1 go to node 3

Print character represented by y go to node 5

Add 3 to y go to node 9

Increment direction by 1 go to node 3

Print character represented by y go to node 6

Subtract 28 from x go to node 9

Increment direction by 1 go to node 1

Print character represented by x go to node 7

Subtract 12 from x go to node 9

Increment direction by 1 go to node 1

Print character represented by x go to node 8

Add 55 to x go to node 9

Increment direction by 1 go to node 1

Print character represented by x go to node 9

Increment direction by 1 go to node 3

Print character represented by y go to node 5

Add 3 to y go to node 9

Increment direction by 1 go to node 3

Print character represented by y go to node 10

Subtract 6 from y go to node 9

Increment direction by 1 go to node 3

Print character represented by y go to node 11

Subtract 8 from y go to node 9

Increment direction by 1 go to node 3

Print character represented by y go to node 12

Subtract 54 from x go to node 9

Increment direction by 1 go to node 1

Print character represented by x go to node 13

End program