Intel ASM 150 bytes

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

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

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

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

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

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

Try it online

True, 16 bytes

"Hello, World!".
­

The language can be spelled with a t

Subleq+, 59 58 57 bytes

Follows the specification described here. Not linking to the Esolangs page as it doesn't have any info in it, but it does link to the Python interpreter created by McChuck05 that I used to test the program.

P:*p !
m p
11 *p !
11 11 P
.m:-1
.p:h
.h:"Hello, World!"0

This solution works because when we compile the code, we find that 11 in Subleq memory points to 0, which is a funny coincidence that I discovered on complete accident when working on writing the Esolangs page for Subleq+.

58 byte version for reference:

P:*p !
m p
Z *p !
Z Z P
.p:h
.m:-1
.h:"Hello, World!"
.Z:0

When the program is run, this is transpiled into the following Subleq program before being executed (93 bytes):

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

If I remember correctly, every program that works in regular Subleq also works in Subleq+ (that is, Subleq+ is upwards-compatible with Subleq), so the resulting Subleq program that is transpiled when we run the program is also technically syntactically correct in Subleq+ itself.

However, Subleq+ adds some really nice features (like pointers and labels) that make it a bit easier to actually golf programs without having to rewrite everything.

Readable version of the solution:

# Main function
Printer: *ptrHW ! # Print the character
moveptr ptrHW     # Move ptrHW to the next location in memory
Zero *ptrHW !     # If we are at the trailing 0, quit
Zero Zero Printer # Else, loop back to the beginning of label "Printer"

# Memory literals
.ptrHW: HelloWorld            # *ptrHW points to HelloWorld string
.moveptr: -1                  # Moves the string pointer
.Zero: 0                      # 0
.HelloWorld: "Hello, World!"0 # Hello World string with trailing null byte

Interactive Thon Langauge, 21 bytes

give("Hello, World!")

Regenerate, 14 bytes

Hello, World\!

Attempt This Online!

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.

Normal 4ME, 21 bytes

P;
out{Hello, World!}

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

fun fact about Normal 4ME:

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

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 t𝐰ice (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(𝐰 + 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 𝐖
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) 𝐰ill return itself as a quine.
WWw                                    Apply the first half of output 𝐰ith
                                         the pre𝐯ious function as argument.
WWWWWWWWWWWWWWWWWWWWWwwww              111 + 3 = 114 r
WWwwwwwwwww                            print 𝐖
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).

Rewriten 4ME, 19 18 bytes

echo{Hello, World!

Try it online

Bespoke, 292 281 280 279 bytes

-11 bytes by not pushing a 0 first. Leads to a Stack underflow. error, but that's OK.

-1 byte by using 1,114,212 for d instead of 100.

-1 byte by using PUSH I at the end of the loop instead of DO COPY.

Hel-lo:its one way message"A B C"goes up
a PC put out a programmed greeting
set the I/O,test out put:A B C?its so ordinary
instead,the He-llo Wo-rld is more cool
but the A B C,that program is truly so easy
and the A"HelloWorld"C,its so lengthy in Bespoke
already,though,it ende-d

Adapted from an example program I included with the official interpreter.

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

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

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

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

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

riscv32 and riscv64 (little endian) machine language for Linux, 38 32 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!\0"
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:       8082                    ret

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

const char main[]="\x05\x45\xef\x05\x20\x01Hello, World!\0\x35\x46\x93\x08\x00\x04\x73\0\0\0\x82\x80";

DEC VAX machine language on UNIX v8 or 4.3BSD, 40 39 33 30 bytes

00: 00 00                                 ;entry mask
02: dd 0d                pushl $0xd       ;len of string
04: df af 0a             pushal $0x11     ;addr of string
07: dd 01                pushl $0x1       ;file descriptor=1
09: fb 03 af ff          calls $3,0x0c    ;call syscall
0d: 04                   ret
0e: bc 04                chmk $04         ;write() syscall
10: 04                   ret
11: 48 65 6c 6c 6f 2c 20 "Hello, World"
    57 6f 72 6c 64 21

The entry mask specifies which regs are saved and other runtime characteristics of the procedure. Because of the way syscalls work on VAX, the golfiest way to make one (as far I know) is a two step procedure (CALLS followed by CHMK). I have also overlapped the end of the CALLS instruction with the start of the entry mask of the syscall procedure.

In honor of the 39th anniversary of mullender.c you can try out the above code by compiling and running the following C program on an actual or emulated VAX.

char main[]={0x00,0x00,0xdd,0x0d,0xdf,0xaf,0x0a,0xdd,0x01,
0xfb,0x03,0xaf,0xff,0x04,0xbc,0x04,0x04,0x48,0x65,0x6c,
0x6c,0x6f,0x2c,0x20,0x57,0x6f,0x72,0x6c,0x64,0x21};

Arsla, 15 bytes

"Hello, World!"

The string gets stored into the stack and gets into output.

Arsla, 17, 16 bytes

"Hello, World!"p

The string is shown in stdout. The space between string is negligible.

smotslang -s, 208 bytes

^{212 -> 208 by using decimal literal}

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

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

Explained:

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

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

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

This answer is #2 of my smotslang challenge sweep

Java, 39 bytes

void main(){IO.print("Hello, World!");}

This is valid from Java 25 onwards.

Java Preview (23), 36 bytes

void main(){print("Hello, World!");}

This uses JEP 477: Implicitly Declared Classes and Instance Main Methods which was previewed in Java 23, but was abandoned in favor of explicitly using the class IO for the final release of the feature in Java 25.

With the preview JDK, run like this:

java --enable-preview Main.java

WE32k machine language on AT&T UNIX System V, 37 34 bytes

00:  84 4c 4a             MOVW  %sp,%ap     ; set argument pointer for upcoming sycall
03:  a0 01                PUSHW &0x1        ; push file descriptor = 1 to stack
05:  37 0f                BSBB  0xf <0x14>  ; push address of string to stack
07:  48 65 6c 6c 6f 2c 20                   ; "Hello, World!"    
0f:  57 6f 72 6c 64 21
14:  a0 0d                PUSHW &0xd        ; push length of string to stack
16:  84 20 41             MOVW  &0x20,%r1   ; select write()
19:  84 04 40             MOVW  &0x4,%r0    ; configure GATE for syscall
1c:  30 61                GATE              ; syscall
1e:  84 08 41             MOVW  &0x8,%r1    ; select exit() syscall
21:  7b f8                BRB   -0x8 <0x19> ; goto 0x19

To try this on an emulator or actual AT&T 3B2 hardware, compile and run the following C program.

char main[]={0x84,0x4c,0x4a,0xa0,0x01,0x37,0x0f,
'H','e','l','l','o',',',' ','W','o','r','l','d','!'
,0xa0,0x0d,0x84,0x20,0x41,0x84,0x04,0x40,0x30,0x61
,0x84,0x08,0x41,0x7b,0xf8};

Emmental, 68 61 54 51 bytes

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

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

Try it online!

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

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

Golf 2: Done using duping and using the queue

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

Unicorn, 15 bytes

OHello, World!/

The last character can be replaced with other characters and still produce the same output, but / is how you're supposed to end the output message.

SAKO, 34 bytes

1)TEKST
Hello, World!
STOP1
KONIEC

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

ppencode, 273 bytes; 73 words

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

Try it online!

Ungolfed

# print "H"
print uc chr ord qw x hex and

# print foreach qw[e l l o]
eval q y
    print chr ord
  foreach qw x else lt lt or x
y xor

# print ","
print chr oct oct ord uc qw q bind q and

# print " "
print q q q and

# print "W"
print chr ord uc q qw q and

# print for qw[o r l d]
eval q y
    print chr ord
  for qw x or read lt do x 
y xor

# print "!"
print chr hex length q q getprotobynumber lt q

Tarfish, 75 bytes

<;....+++.:{.}+.:.}}.:+++:..::+{x++++++.:+:{x+++++++++++++:++++++++++++.x+x

Try It Online!

Note: The explanation is formatted similarly to the one found in @emanresu A's answer, where multiple + signs are truncated into a single +, the exact count is specified in the comment, and the current stack is shown at the end of each comment.

<                                            # Change direction of IP to left
                                         +x  # Push x coordinate (74) and increment   - 'K'
                                       .x    # Push x coordinate (72) and output      - 'K'
                                      +      # Increment by 12                        - 'W'
                                    +:       # Duplicate and increment by 13          - 'Wd'
                                  {x         # Push x coordinate (44) and shift right - ',Wd'
                                +:           # Duplicate and increment once           - ',Wde'
                              .:             # Duplicate and output                   - ',Wde'
                             +               # Increment by 6                         - ',Wdk'
                           {x                # Push x coordinate (32) and shift right - ' ,Wdk'
                          +                  # Increment once                         - ' ,Wdl'
                      ..::                   # Duplicate twice and output twice       - ' ,Wdl'
                    +:                       # Duplicate and increment by 3           - ' ,Wdlo'
                  .:                         # Duplicate and output                   - ' ,Wdlo'
               .}}                           # Shift left twice and output            - 'Wdlo '
             .:                              # Duplicate and output                   - 'Wdlo '
            +                                # Increment once                         - 'Wdlo!'
          .}                                 # Shift left and output                  - 'dlo!'
       .:{                                   # Shift right, duplicate then output     - '!dlo'
      +                                      # Increment by 3                         - '!dlr'
 ;....                                       # Output 4 times and halt

UNAI, 15 bytes

Array? has been rebranded into UNAI

"Hello, World!"

Cray J90 Supercomputer machine language on UNICOS, 88 82 80 bytes

00a: A1              4          ; 0022104
00b: S0              A1         ; 0071001 Select write() syscall
00c: A0              B66        ; 0024066 put stack pointer in A0
00d: S7              1          ; 0042777
01a: 0,A0            S7         ; 0130700 push file descriptor to stack
01b:                            ; 0000000
01c:                            ; 0000000
01d: A2              3          ; 0022203
02a: A1              A0+A2      ; 0030102
02b: 1,A0            A1         ; 0110100 push address of string to stack
02c:                            ; 0000001
02d:                            ; 0000000
03a: A1              13         ; 0022115
03b: 2,A0            A1         ; 0110100 push length of string to stack
03c:                            ; 0000002
03d:                            ; 0000000
04a: S6              1214606444 ; 0040600 "Hell" into S6
04b:                            ; 0066154
04c:                            ; 0044145
04d: S6              S6<32      ; 0054640 shift S6 left 32 bits
05a: S7              1865162839 ; 0040700 "o, W" into S7
05b:                            ; 0020127
05c:                            ; 0067454
05d: S7              S6+S7      ; 0060767 S7 <= S6 or S7
06a: 3,A0            S7         ; 0130700 push "Hello, W" onto stack
06b:                            ; 0000003
06c:                            ; 0000000
06d: S6              1869769828 ; 0040600
07a:                            ; 0066144
07b:                            ; 0067562
07c: S6              S6<32      ; 0054640
07d: S7              553648128  ; 0040700
10a:                            ; 0000000
10b:                            ; 0020400
10c: S7              S6+S7      ; 0060767
10d: 4,A0            S7         ; 0130700 push "orld!" onto stack
11a:                            ; 0000004
11b:                            ; 0000000
11c: EX                         ; 0004000 syscall
11d: J               B00        ; 0005000 return addr is in B00

The Cray family of supercomputers are 64 bit word addressed machines. Instructions fit in multiples of 16 bit "parcels". Like the CDC machines that Seymour Cray designed, addresses and instructions are represented in octal (they have been translated to hex in the C program below). Parcel addresses are a through d. Here, the string Hello, World! is pushed onto the stack after syscall arguments are pushed.

Special thanks to Andras Tantos and his Cray Simulator! If you have UNICOS installed on a simulator or a machine cooled with Fluorinert, you can compile and run this C program.

char x[]="\x24\x44""\x72\x01""\x28\x36""\x45\xff""\xb1\xc0""\x00\x00"
         "\x00\x00""\x24\x83""\x30\x42""\x90\x40""\x00\x01""\x00\x00"
         "\x24\x4d""\x90\x40""\x00\x02""\x00\x00""\x41\x80"      "ll"
               "He""\x59\xa0""\x41\xc0"      " W"      "o,""\x61\xf7"
         "\xb1\xc0""\x00\x03""\x00\x00""\x41\x80"      "ld"      "or"
         "\x59\xa0""\x41\xc0""\x00\x00"     "!\0""\x61\xf7""\xb1\xc0"
         "\x00\x04""\x00\x00""\x08\x00""\x0a\x00";

main(){
  ((int(*)())x)();
}

EDIT: It turns out to be golfier to do A1 4; S0 A1; instead of S0 4

Welcome to Esolang, the esoteric programming languages wiki, 7 bytes

Welcome

Interpret this online!

Self-Modifying Trilangle, 29 bytes

<_.)>(o@.#\,../␀!dlroW ,olleH

(␀ should be an actual NUL byte)

:3

H🌍, 2 bytes

Here is it, a 2 bytes answer... hw

Try it here

Jalapeño, 14 bytes

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

Just the raw string as a base 254 string.

Hex-Dump of Bytecode

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

Try it Online!

HolyC, 24 bytes

Print("Hello, World!");

Nothing special here, I just wanted to pay tribute to Terry Davis who wrote TempleOS and its companion language, HolyC.

RBFuck, 138 bytes

Basically a subset of Ruby that doesn't contain letters or numbers in its source code.

__=">:("=~/$/
_=__*__
$__=_*_
_=-~_
$_=_*_
$.=$_+~-~-_
$><<(""<<$__-~-_<<-~$_<<$.<<$.<<$_-~_<<", "<<$__+__+__<<$_-~_<<$_-~_+__<<$.<<$_)+?!

Try it online!

StackCell, 20 bytes

"!dlorW ,olleH":[;:]

Hatchback, 145 bytes

0 0 72 13 0 0 0 101 13 0 0 1 108 13 1 13 1 0 2 111 13 2 0 0 44 13 0 0 0 32 13 0 0 0 87 13 0 13 2 0 0 114 13 0 13 1 0 0 100 13 0 0 0 33 13 0 65535

this is a very boring way of doing it, it's just printing every char one by one.

Just, 16 bytes

"Hello, World!"#

Ending a string with a newline, 16 bytes

"Hello, World!
#

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

")hello)18 )world)0x

PDP-11 machine language on BSD 2.11, 37 34 bytes

00: 15ce 000d mov $15,(sp) ; len of string on stack
04: 09f7 000e jsr pc, 26   ; addr of string on stack
10: 6548 6c6c              ; "Hello, World!"
    2c6f 5720
    726f 646c
    0021
26: 15e6 0001 mov $1,-(sp) ; stdout on stack
32: 15e6 0001 mov $1,-(sp) ; stack padding
36: 8904      trap 4       ; write() syscall
40: 8901      trap 1       ; exit() syscall

Note that BSD 2.11 does not use the same syscall convention as previous UNIXes for the PDP-11. As a result, some previous winners of the IOCCC may not work out of the box on BSD 2.11.

To try this on a real or emulated PDP-11 running BSD 2.11 (this won't work on other operating systems), compile and run the following C program.

char main[]={0xce,0x15,0x0d,0x00,0xf7,0x09,0x0e,0x00,'H','e'
,'l','l','o',',',' ','W','o','r','l','d','!',0x00,0xe6,0x15,
0x01,0x00,0xe6,0x15,0x01,0x00,0x04,0x89,0x01,0x89};

PDP-11 machine language on UNIX v7 or BSD 2.9, 36 bytes

00: 15ce 8901 mov $104401,(sp) ; exit()
04: 15e6 000d mov $15,-(sp)    ; len of string
10: 09f7 000e jsr pc, 32       ; addr of string
14: 6548 6c6c                  ; "Hello, World!"
    2c6f 5720
    726f 646c
    0021
32: 15e6 8904 mov $104404,-(sp); write()
36: 15c0 0001 mov $01,r0       ; fd=1
42: 004e      jmp sp           ; jump to stack

Older UNIXes for the PDP-11 had a different syscall convention in which some of the arguments are placed right after the trap instruction. Therefore, almost every syscall requires some self modifying code! The approach here is to generate a "Hello, World!" program on the stack and then jump to the stack.

To try this on a real or emulated PDP-11 running AT&T UNIX, compile and run this C program (if the compiler is very old, remove the =).

main[]={5582,-30463,5606,13,2551,14,25928,27756,
11375,22304,29295,25708,33,5606,-30460,5568,1,78};

AutoHotkey (v2), 30 bytes

FileAppend "Hello, World!","*"

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

> autohotkey hello.ahk | echo
Hello, World!

Seed, 3018 2017 bytes

20 3082878908023217264513409052095171166514152842731930860020030457993938638103403046250429562326112485829082935625771107516331023825155872901669415648235325447829426022284731164161891694720812374369453386524432410088164372170392956375395850689218364904174051952470305204799797137492740045183552010004821283992680236683735370859514390654072426410106330267139172209696472898496287558925238447139030179194624772827195264332239950898118676727321207243048939596359970569757556221587682401886866880889418724996826640174762320680632047593443900996789395015891356171155967406840304248410954549718823482438299131238585880493998113081588276800215314525942008386904934685038679246400738476994830932995595042223007150138433182378368856326735623459072988527721649311845975051626763201500896435813636290161356206562461644002558629746848593535516946270399998865651156040448544009517828826581130144797960705038588693024754437428875398353878997423338275398606001191881568405816726989525613118944553638022766028623131205844952060481792579363922109325705770987967601483747182833561634649000267202311571235633450511362086958884460954233386294994726147926121474733199263222833226197679493330337301148364461552762233800441924062279992700913213329489815877097171879946903013904332718444777265905637279466069041198148023820086777140202508571700410956007492647684095439617571010925425123943514345926493154490345652668771443492562053776680425265050119765135181788296734019469696538700085279784407818295554337104198697313062299826062766791781812122456707026148958864981773433414886373640448328410245912057087921426298934444319913947680360457830122708046500222410739143123748002253812309125636207440858046130948803365528714178861564980421910125372812125423460512165456922794335092421977093496568379541718255553659331424015361340170529327971274047454126957271742377889431517805084441157214774131176212324130225944626167827592713912233615105381610752889019892570309634158768321187824903681103890790043094957669446947795125894500903082171110417933

Try it online!

Existing answers in Seed:

• Kamila's answer, 4154 bytes
• feersum's answer, 4203 bytes

The Befunge program is identical to the previous answers:

"9!dlroW ,olleH"ck,@

The Seed interpreter is in https://github.com/TryItOnline/seed/blob/master/seed . It uses Python 2 instead of 3. In Python 2, randint is defined by

randint(32, 127) == 32 + int(random() * (127 - 32 + 1))

Apart from that, random() is defined identically to Python 3. It's not in Python file however, it's implemented in C: https://github.com/python/cpython/blob/master/Modules/_randommodule.c See _random_Random_random_impl. Specifically,

random() == ((getrandbits(32)>>5) << 26 | (getrandbits(32)>>6)) / (2**53)

(evaluate left to right)

Pascal, 32 bytes

BEGIN WRITE('Hello, World!')END.

Joeasus, 2 1 byte

,

Try it Online!

Original solution

hw

Try it Online!

Yes I know very silly.

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

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

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

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

int main[]={0x4878000d,0x610e4865,0x6c6c6f2c,0x20576f72,
0x6c642100,0x48780001,0x48780001,0x48780004,0x4e404e40};

Nythop, 21 bytes

)"!dlrow olleH"(tnirp

Never make a Python version of Pain-Flak

'Python' is not recognized, 24 bytes

|H|e|l|l|o| |W|o|r|l|d|!

Try it online

BrainChild, 32 31 bytes

include*;print("Hello, World!")

Try It Online!

Factor, 17 21 bytes

Push a string, then print it without quotes.

"Hello, World!" print

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

GAIA, 14 bytes

“Hello, World!

Try it online!

Python 3, 22B:

print("Hello, World!")

TinyAPL 0.9.0, 21 bytes

(17 chars)

⎕←"Hello, World!"

Template Qdeql, 128 bytes

h:184 h::-e:155*l:148 e::-o:145*c:212 l::-s:224*w:169 l::-r:142*d:156
o::-e:223*c::- *s::- *w::- *o::- *r::- *l::- *d::- *e::- *

This is just the "Hello, World!" example, with a few minor changes:

• The comment has been removed and all the integer names were shortened to 1 bytes
• The integer definitions were constant-folded
• The instructions and definitions have been interleaved, to reduce the amount of whitespace needed.

The whitespace could be anything matching the JS regex \s, but I did mostly spaces and one newline for legibility.

Hippopotomonstrosesquipedalian 2, 9465000 Bytes

The bytecount is only approximate, and the files would hang my computer if I pasted their contents so here is the link.

Documentation

Each word represents a 1 or 0. "pneumonoultramicroscopicsilicovolcanoconiosis" represents a 1 when a word that has 189819 letters (the long name for titin) represents a 0.

Messenger, 225 bytes

v>8v> *v>v >v >v >v>v >v  >v >v >v >v >v >v >v >v >v >v
>S    7>S>/S1>S>+S>S3>S>/ S7>S>-S>*S>-S>*S>/S>+S>-S>-S>v
 >9*^S^ 5  >+ 7    >+ 3 v S+ 5   3  9  9  7  3  6  8  3/
  vS ^  >^ vS^>^vS>vS^>^>   ^>^vS^ >^vS^ >^vS^vS^vS^vS^

Messenger is my first (completed) esolang. It works in 2D, and it uses messages for storage, rather than variables or stacks. This makes it tough to code in, since timing and placing have to be managed so that the code doesn't break (or worse, throw an error).

A Python 3.8+ interpreter which works from the command line can be found here. To use it in Try It Online, IDLE, etc., remove the ## WHILE RUNNING ## section of the code.

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:

#!/usr/bin/env perl

# Usage: perl $0 STRING
# Generates a code that stores given STRING
# to ;1 array in CLC-INTERCAL's binary IO model
# so it can be output by DOREADOUT;1, 
# without spaces.

my $line = shift;
my @values = unpack("C*", $line);
    my $ptr = 0;
    my @val = ();
    my $io = 172;
    for my $datum (@values) {
        my $chr = $datum;
        my $chr0 = $chr;
        my $bits0 = 0;
        my $bits1 = 0;
        for (my $i = 0; $i < 8; $i++) {
            if ($io & 0x80) {
                $bits0 <<= 1;
                $bits0 |= 1 if $chr & 0x80;
            } else {
                $bits1 <<= 1;
                $bits1 |= 1 if ! ($chr & 0x80);
            }
            $chr <<= 1;
            $io <<= 1;
        }
        $chr = int(rand 0xffff) + 1;
        for (my $i = 0; $i < 8; $i++) {
            $chr <<= 2;
            $chr |= 2 if $bits0 & 0x80;
            $chr |= 1 if $bits1 & 0x80;
            $bits0 <<= 1;
            $bits1 <<= 1;
        }
        $datum = $chr;
        $io = $chr0;
    }
print "DO;1<-#" . @values;
for my$i(0..$#values) {
   my $clcii = $i + 1;
   my $x = $values[$i] & 0xffff;
   print 'DO,1SUB#' . $clcii . '<-#' . $x if $x;
}

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.

Therefore I had to use binary I/O instead to shorten the program.

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.

ACCUMULATOR, 103 102 bytes

-1 bytes from @SanguineL

ACMMMMCMMMMMURACMMCAAUAAAAAAAUUAAAURAAAACURAAACMURACMMMCMURACMMCAAAAAAAAAAAAUAAAUMMMMMMURACMMCAURAAACU

Follow the header link to try it online; note that you will have to paste the code in.

According to the language's Esolangs wiki page, ACCUMULATOR was designed by UndoneStudios for the main purpose of "solving the uselessness problem of the accumulator in most languages that have one."

As of writing this answer (05/28/2024), ACCUMULATOR only has these 6 commands:

• A and M to increment and decrement the accumulator respectively,
• O and U to output the number and Unicode representations of the accumulator respectively,
• C to concatenate the accumulator with itself (e.g., if the accumulator is 21 then with C it becomes 2121),
• and R to reset the accumulator to 0.

Clarity, 16 bytes

Source:

"Hello, World!"

Output:

Hello, World!

Try it online!

Works in the Clarity console, outputs "Hello, World!". If you want to output it on the blockchain, which prints a lengthier output though, do this:

(print "Hello, World!")

Output:

Events emitted
{"contract_event":{"contract_identifier":"ST000000000000000000002AMW42H.contract-2","topic":"print","value":"\"Hello, World!\""},"type":"contract_event"}

Lazy K, 555 bytes

k(s``si`k``s``sss``s``ss``ss0``ss0``s``si`k``ss``s``ss0``ss(ss`ss``ss0)(s`0001ki
`s``si`k``s``si(ssi``ss0)(ssi``ss``ss0)``s``si`k``ss``s``sss``ss(ss`ss``ss0)``s`
`si`k``ss``ss``s``sss``s``sss``ss0``s``si`k``s``ss(ssi``ss0)``ss0``s``si`k``s``s
i``ss``ss0``ss``ss(ssi``ss``ss0)``s``si`k``ss``s``sss``ss(ss`ss``ss0)``s``si`k``
s``si``ss0``ss``s``sss``ss``s``sss``ss0``s``si`k``s``si(ssi``ss0)(ssi``ss``ss0)`
`s``si`k``s``ss0``ss(ss`ss``ss0)``s``si`k``ss``s``ss(ssi``ss0)``ss0``s`k(si`s`k`
si``sii)``si`k(ssi(ssi``ss0)))``s`0001`001`0001``s`k`si`001``si`k`0001k`kk)

ACCUMULATOR, 134 bytes

I spent 10 minutes on this.

AAAAAAACMMMMMUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAUUAAAURAAAACURAAACMURAAAAAAAACMUAAAAAAAAAAAAAAAAAAAAAAAAUAAAUMMMMMMUMMMMMMMMURAAACU

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 a brute forcer at its 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 its right allowing it to be simplified to [.>]< bringing it down to 72.

I let it run for quite a while 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.

AWK, 18 bytes

$0="Hello, World!"

Try it online!

AWK defaults to {print $0}. Pass/pipe this anything and it will just print "Hello, World!".

echo "" | awk '$0="Hello, World!"'

Befalse (quirkster), 22 bytes

"!dlroW ,olleH"::::..;

Try it! (Usage: copy-paste into the code box, click Show above it, and then Run.)

So this is the golfiest way to repeat a single command a finite number of times and halt in Befalse.

: (Call) pushes the position to return onto the return stack so that ; (Ret) can return to the instruction after the corresponding :. As in Modular SNUSP, the return position is two steps away from the position of :. When the return stack is empty at ;, the program ends.

::::..; happens to execute . exactly 13 times:

::::..;
ABCDEF
starting at E, `.` is run twice
starting at D, `.` is run 3 times (EF, then return to F)
starting at C, `.` is run 5 times (DEF, then return to E)
starting at B, `.` is run 8 times (CDEF, then return to D)
starting at A, `.` is run 13 times

JSL - JMP Scripting Language, 15 bytes

In this challenge the most difficult part was to check whether JSL had no submissions yet (977 answers on 33 pages) =))

"Hello, World!"

Outputs "Hello, World!" to the console.

Acc!!, 61 bytes

195657271854030749545429
Count i while _ {
Write _%83+32
_/83

Try it online!

Stores the string Hello, World! as an integer in base-83 then uses a loop to decode and print it.

Note that Acc!! doesn't automatically close braces but due to a bug(?) in the official interpreter you are able to omit the closing brace if you don't use the associated loop variable.

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

Easyfuck, 18 16 bytes

¶ąőŘ␒2ěŮ˝b
űůlČ„

Decompressed:

[.>]@Hello, World!

[.>]@Hello, World!
[  ]               while loop
 .>                print and move to the next cell
    @              end program
     Hello, World! initializer data

Positionally, 80 bytes

/


        ^+     <
DH  !"! C ! K !Q!N!6! +N!K !K!
      ;<
       /  s    /

Try It Online!

Positionally, ¹⁵³ 81 bytes

/     \
  1    \       \

  -    <^
fI  I""em s p X!-pmm
      ;
   j      s    /

Try It Online!

Explanation

In contrast to many 2D-programming languages where the character itself signifies the command, Positionally differentiates itself by using the positions of non-whitespace characters to dictate the command executed. This unique approach effectively precludes the possibility of writing "flat" programs.

The language disregards all spaces, even those within strings, making output of the space in Hello, World! particularly challenging. As a workaround, the program inserts the string "emspX!-pmmfI (note this is overlaid on top of functional parts of the program) and then outputs it in reverse, decrementing each character's ASCII value by 1 to achieve the desired Hello, World!.

Yoda-Lang, 23 bytes

"Hello, World!" you say

I haven't figured out how to install Yoda-Lang so I can't tell if I can remove any spaces. I'll give another try at installing it soon, since this looks like a genuinely interesting language.

m4, 13 bytes

Hello, World!

Try it online!

Trivial solution!

Uiua, 17 bytes

&p"Hello, World!"

Explanation:

&p"Hello, World!"
  "Hello, World!" # push our dear string to the stack
&p                # print with newline

Try it online!

D, 42 bytes

Something reminded me of this challenge today, so together with a few folks on the D Discord server, we devised what might be, however cursed, the shortest D hello world.

import std;@0main()=>"Hello, World!".puts;

Firstly, for some versions now, import std imports a large part of std modules including std.stdio, which saves 6 bytes from the usual solution. Secondly, we abuse AutoFuncDeclaration and User-Defined Attributes to apply a 0 literal as a function attribute, letting us omit the return type void. And, as it turns out, the D parser does not forbid placing identifiers right after numbers, letting us combine this into @0main. This might appear to be the devil's own creation but is 3 bytes shorter than the usual void main. Lastly, by using UFCS and substituting write or writeln for puts we save further 2 bytes.

We use the arrow notation for general "golfiness" but it's exactly the same length as if we had used braces, i.e. @0main(){...}

A questionable alternative, 38 bytes

pragma(msg,"Hello, World!");@0main(){}

While the program produced by this is valid, it doesn't do anything, and "Hello, World!" is printed during compilation.

IBM z/Architecture machine language on Linux, 31 bytes

00:   a7 29 00 01         lghi    %r2,1.          # fd=1
04:   c0 30 00 00 00 07   larl    %r3,742 <+0x12> # set address of string
0a:   a7 49 00 0d         lghi    %r4,13          # set length of string
0e:   0a 04               svc     4               # write() syscall
10:   0a 01               svc     1               # exit() syscall
12:   48 65 6c 6c                                 # "Hello, World!"
16:   6f 2c 20 57
1a:   6f 72 6c 64
1e:   21

To try this on an emulator or actual machine, compile and run the following C program.

const char main[] __attribute__((section("rodata")))=
"\xa7\x29\x00\x01\xc0\x30\x00\x00\x00\x07\xa7\x49\x00"
"\x0d\x0a\x04\x0a\x01Hello, World!";

On a 31 bit machine (or 64 bit machine in 31 bit mode) change the lghi instructions to lhi which can be done by clearing the 16th most significant bit (0x29 becomes 0x28; 0x49 becomes 0x48).

PA-RISC 1.1 machine language on HP-UX 10.20, 53 48 bytes

00:  eb 20 00 20  bl 18,r25     # load address of string to %r25
04:  34 1a 00 02  ldi 1,r26     # branch delay slot, fd=1 to %r26
08:  00 00 00 48                # "Hello, World!"
0c:  65 6c 6c 6f
10:  2c 20 57 6f
14:  72 6c 64 21
18:  34 16 00 08  ldi 4,r22     # select write() syscall
1c:  20 20 08 01  ldil -40000000,r1
20:  e4 20 e0 08  ble 4(sr7,r1) # HP-UX syscall
24:  34 18 00 1a  ldi d,r24     # branch delay slot, length of string to %r24
28:  e8 1f 1f dd  b 1c          # goto 0x1c
2c:  34 16 00 02  ldi 1,r22     # branch delay slot, select exit() syscall

(UNTESTED) For Linux, you may have to change the syscall instruction to ble 0x100(%sr2, %r0) and may be able to remove ldil -40000000,r1

To try this on a PA-RISC machine or emulator, compile and run the following C program.

int f[]={0xeb200020,0x341a0002,'H','ello',', Wo','rld!',0x34160008,
         0x20200801,0xe420e008,0x3418001a,0xe81f1fdd,0x34160002};
int main(){
  ((int(*)())f)();
}

Vyxal 3, 8 bytes

"Ḍᵗ{w<ᵏ”

Try it Online!

Vyxal 3 just dropped.

MetaBrainfuck -x, (22 bytes)

"Hello, World!"{{+}.>}

Explanation

"Hello, World!"{     }     # for each character in the string "Hello, World!"
                {+}.>      # repeat + that many times, then append .>

expands to the following Brainfuck program:

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++.>

which when executed (-x flag) prints Hello, World!

Noulith, 15 bytes

"Hello, World!"

Implicitly outputs the string.

https://betaveros.github.io/noulith/#IkhlbGxvLCBXb3JsZCEi

􏿾 (U+0001 and U+10FFFE), 158 bytes

1-1>11<1>1111<11>11<1>1<1>1<11>1<11>111<11>1<11>111<11>1<1111>11<1>1<11>1111<1>111111<1>1<1>1<111>1<11>1<1111>1<111>11<1>11<11>1<11>111<11>11<1>1111<1>1111<1􏿾

Ends with the character U+10FFFE, but since this language has only 13 builtins (including that character), I've decided to score each character as a single byte.

H🌍, 2 Bytes

hw

I discovered this language a few minutes ago.

Try it online! (Modified interpreter located in header and footer.)

{High}, 16 bytes

"Hello, World!";

Two new languages at once!

{,}, 2279 Chars or \$2279\log_{256}(4)\approx\$ 569.75 Bytes

({(())},()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(),()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())

Completely ungolfed (for now)

Rec, 47 46 bytes

Saved a byte thanks to bsoelch

72p101p108 0:0:pp111p44p32p87p111p114pp100p33p

Try it online!

Minecraft Function, 26 bytes

tellraw @a "Hello, World!"

AArch64 machine language Linux, 48 45 37 bytes

00:   d2800020        mov     x0, #0x1  ; stdout is fd=1
04:   100000a1        adr     x1, 18    ; put addr of string to x1
08:   d28001a2        mov     x2, #0xd  ; length of string
0c:   d2800808        mov     x8, #0x40 ; select write() syscall
10:   d4000001        svc     #0x0      ; syscall
14:   d65f03c0        ret
18:   6c6c6548        "Hello, World!"
1c:   57202c6f
20:   646c726f
24:   00000021

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.

int main[]__attribute__((section(".text")))={0xd2800020,0x100000a1,0xd28001a2
,0xd2800808,0xd4000001,0xd65f03c0,'lleH','W ,o', 'dlro', '!'};

Alpha AXP machine language on OSF/1, 40 bytes

0x00:   d2200004    bsr a1, 0x14(zero)    # Set a1 to pointer of string
0x04:   6c6c6548    "Hello, World!\0\0\0"
0x08:   57202c6f
0x0c:   646c726f
0x10:   00000021
0x14:   43e09400    addq    zero, 0x4, v0 # Select write() syscall
0x18:   43e03410    addq    zero, 0x1, a0 # stdout
0x1c:   43e1b412    addq    zero, 0xd, a2 # string length
0x20:   00000083    call_pal    callsys   # write(1, str, len)
0x24:   6bfa8001    ret zero, (ra), 1     # return

To try this on a suitable machine or emulator, compile and run the following C program

int main[]={0xd2200004,0x6c6c6548,0x57202c6f,0x646c726f,0x21,
            0x43e09400,0x43e03410,0x43e1b412,0x83,0x6bfa8001};

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[]="\x40\x00\x00\x02\x82\x10\x20\x04\x90\x10\x20\x01\x92\x03\xe0\x20\x94\x10\x20\x0d\x91\xd0\x20\x08\x82\x10\x20\x01\x91\xd0\x20\x08Hello, World!";

EDIT: To try this on Linux (for SPARC), change the argument of the trap instruction to 16 for 32 bit mode and 109 for 64 bit mode.

Koka, 31 bytes

fun main()print("Hello world!")

Attempt This Online!

Perl 5, 171 bytes

$_=chr(72);print$_,chr(69);@l=(1..2);for(@l){print"L"}sub o{$o=79;print(chr($o));}o();my $h=32;print chr($h),'W';o();$r='R';print$r;$_=chr(76);print;$d=0;print chr($d+68);

Try it online!

(,) 375 344 334 Chars or \$334\log_{256}(3)\approx66.17\$ Bytes

(()()(),()()()()()()())((),(()()())()()())((()),(())(())(()))(((())),((()))((()))(()))(,,,(((())))()())(()(),(((())))((()))())(,,,(()()))(,,,(()())(()()()),(),,()())(,,,(()())(()))(,,,((()))(())()()()())(,,,((()))()())(,,,(((())))(())(()()()))(,,,(()())(()))(,,,(()())(())()()())(,,,(()())(()()()))(,,,(((())))((())))(,,,((()))()()())

Can likely still be golfed a lot.
Tio

Shasta ^v0.0.5, 24 bytes

(print["Hello, World!"])

Shasta is a new programming language I've been developing for the past couple of days, and I've finally got it to a state where I can start to answer some challenges on the site here. It is inspired by Lisp and Python, and transpiles to JavaScript. I'll update the header once the language gets a bit more stable; it's possible (though very unlikely) that this Hello World program won't work anymore in the future.

I haven't set up an online interpreter yet, so for now you can install Shasta off NPM with npm install --global shasta-lang@0.0.5, and run it via the CLI:

echo '(print["Hello, World!"])' | shasta-lang | node
Hello, World!

Commodore C64 BASIC (Non-competing/just for fun), 36 Tokenised BASIC bytes, 34 PETSCII characters

0LIST:REM"{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}{DEL}HELLO, WORLD!

This uses a trick to hide a BASIC line, by starting a REM statement with a quotation mark, you may use the delete control character (CTRL+T) which is displayed as a reversed T character (see screen shot below). When you RUN the program, the line number, LIST and REM command are hidden by the text HELLO, WORLD!. You get the same output when you LIST the program too.

TalkingHead, 11 seconds

The first sound based programming language!!!

Sound File

Num Stack Arithmac, \$165\times\log_{256}(16)=82.5\$ Bytes

++^++++^++++++++q+++++++++++++++++++++++++++++q+++++++qq+++q-%++^-^---^++++++++q------------q%+++^^++++++q++++++++++++++++++++++++q+++q------q--------q%++^-^---^---q

Well, there are actually 13 builtins (Including <> for comments but not all the characters that can go in them). Since people do not like when the \$\log\$ method produces irrational numbers, I have chosen to take the \$\log\$ of 16 instead. If someone knows how to contact the TIO person to add a new programming language, please comment below. Anyways, to run this script in command prompt (>>> denotes what you type in):

>>> pip install num-stack-arithmac
>>> python3
>>> from num_stack_arithmac import compile

Welcome to Num Stack Arithmac!




Enter the filepath or code you want to run (or type "g" for a graphical editor with no support for saving and opening files):

>>> ++^++++^++++++++q+++++++++++++++++++++++++++++q+++++++qq+++q-%++^-^---^++++++++q------------q%+++^^++++++q++++++++++++++++++++++++q+++q------q--------q%++^-^---^---q


Enter the starting number:

>>> 

Now the programme will print Hello, World!. The programming language has implicit input. If the programme you are running requires no input, do not enter anything. The starting number will default to 0. You can also type g instead of the code for a window to pop up in which you can paste the code in and run the programme.

Vyxal, 10 bits^v1, 1.25 bytes

kH

Try it Online!

Pushes the string "Hello, World!"

Alternatively,

Vyxal, 50 bits^v1, 6.25 bytes

`ƈṡ, ƛ€!

Try it Online!

Thunno 2, 2 bytes

kH

Attempt This Online!

Polyglots with Vyxal. Constant for "Hello, World!".

Thunno 2, 8 bytes

’Ƙ¥, «ʋ!

Attempt This Online!

Dictionary compressed string.

Java 5, 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 this solution uses a bypass^[1] that 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.

Acc!!, 122 bytes

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

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

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

Works the same in Acc!.

hyperscript, 27 24 bytes

init log 'Hello, World!'

<script src="https://unpkg.com/hyperscript.org@0.9.8"></script>
<script type="text/hyperscript">

init log 'Hello, World!'

</script>

Calls the log command when the document is initialized.

Axo, 29 bytes

"!dlroW ,o%
\%#[<"Hell<
 >( ^

Please let me know if this can be golfed further.

Logically, 1046 Bytes

@A:3i:o,c:4t;XOR(3i)(t3)AND(i0,i1)(t0)AND(i1,i2)(t1)AND(i0,i2)(t2)COPY(t3)(o)OR(3t)(c)
@B:8a,8b:8o,d:7c;A(a0,b0,0)(o0,c0)A(a1,b1,c0)(o1,c1)A(a2,b2,c1)(o2,c2)A(a3,b3,c2)(o3,c3)A(a4,b4,c3)(o4,c4)A(a5,b5,c4)(o5,c5)A(a6,b6,c5)(o6,c6)A(a7,b7,c6)(o7,d)
@C:i,a,b:d:x,y,z;NOT(i)(x)AND(a,x)(y)AND(b,i)(z)OR(y,z)(d)
@D:i,8a,8b:8o;C(i,a0,b0)(o0)C(i,a1,b1)(o1)C(i,a2,b2)(o2)C(i,a3,b3)(o3)C(i,a4,b4)(o4)C(i,a5,b5)(o5)C(i,a6,b6)(o6)C(i,a7,b7)(o7)
@E:1i,i,16a,16b:8o:8c,8d;D(1i,16a)(8c)D(1i,16b)(8d)D(i,8c,8d)(8o)
@F:2i,i,32a,32b:8o:8c,8d;E(2i,32a)(8c)E(2i,32b)(8d)D(i,8c,8d)(8o)
@G:3i,i,64a,64b:8o:8c,8d;F(3i,64a)(8c)F(3i,64b)(8d)D(i,8c,8d)(8o)
@H:i:p:b_HIGH;NOT(i)(b)AND(i,b)(p)
@I:i:o:16d;COPY(i,16d)(16d,o)
@J B:8a,8i,b,r,d,8c;B(8a,1)(8i)CELL(b,8i)(8a)H(H)(r)OR(r,b)(d)I(d)(b)WRITE(b,8c)()G(4a,0,0,0,1,0,0,1,0,1,0,1,0,0,1,1,0,0,0,1,1,0,1,1,0,0,0,1,1,0,1,1,0,1,1,1,1,0,1,1,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,1,0,1,0,1,1,1,1,0,1,1,0,0,1,0,0,1,1,1,0,0,0,1,1,0,1,1,0,0,0,1,0,0,1,1,0,1,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1)(8c)HALT(c7)()

Ungolfed

@2BitAdder
: 3in;
: out, carry;
: 4t;
XOR  (3in)           (t3)
AND  (in0, in1)      (t0)
AND  (in1, in2)      (t1)
AND  (in0, in2)      (t2)
COPY (t3)            (out)
OR   (3t)            (carry)

@ByteAdder
: 8a, 8b;
: 8o, carry;
: 7c;
2BitAdder (a0, b0, 0)  (o0, c0)
2BitAdder (a1, b1, c0) (o1, c1)
2BitAdder (a2, b2, c1) (o2, c2)
2BitAdder (a3, b3, c2) (o3, c3)
2BitAdder (a4, b4, c3) (o4, c4)
2BitAdder (a5, b5, c4) (o5, c5)
2BitAdder (a6, b6, c5) (o6, c6)
2BitAdder (a7, b7, c6) (o7, carry)

@Mux
: i, a, b;
: d;
: ni, ani, bi;
NOT (i)       (ni)
AND (a, ni)   (ani)
AND (b, i)    (bi)
OR  (ani, bi) (d)

@ByteMux
: i, [8d0], [8d1];
: [8o];
Mux (i, d00, d10) (o0)
Mux (i, d01, d11) (o1)
Mux (i, d02, d12) (o2)
Mux (i, d03, d13) (o3)
Mux (i, d04, d14) (o4)
Mux (i, d05, d15) (o5)
Mux (i, d06, d16) (o6)
Mux (i, d07, d17) (o7)

@4ByteMux
: 1i, i, 16a, 16b;
: 8o;
: 8c, 8d;
ByteMux (1i, 16a)    (8c)
ByteMux (1i, 16b)    (8d)
ByteMux ( i, 8c, 8d) (8o)

@8ByteMux
: 2i, i, 32a, 32b;
: 8o;
: 8c, 8d;
4ByteMux (2i, 32a)     (8c)
4ByteMux (2i, 32b)     (8d)
ByteMux  ( i, 8c,  8d) (8o)

@FByteMux
: 3i, i, 64a, 64b;
: 8o;
: 8c, 8d;
8ByteMux (3i, 64a)    (8c)
8ByteMux (3i, 64b)    (8d)
ByteMux  ( i, 8c, 8d) (8o)

@RisingEdge
: in;
: pulse;
: bar_HIGH;
NOT (in)      (bar)
AND (in, bar) (pulse)

@Delay
: in;
: out;
: 16d;
COPY (in, 16d) (16d, out)

@Main
Bus: 8a, 8i, clock, risingPulse, delayIn, 8c;
ByteAdder       (8a, 1) (8i)
CELL            (clock, 8i)             (8a)
RisingEdge      (H)                     (risingPulse)
OR              (risingPulse, clock)    (delayIn)
Delay           (delayIn)               (clock)
WRITE           (clock, [8c])           ()
FByteMux        (4a,
                0,0,0,1, 0,0,1,0,
                1,0,1,0, 0,1,1,0,
                0,0,1,1, 0,1,1,0,
                0,0,1,1, 0,1,1,0,
                1,1,1,1, 0,1,1,0,
                0,0,1,1, 0,1,0,0,
                0,0,0,0, 0,1,0,0,
                1,1,1,0, 1,0,1,0,
                1,1,1,1, 0,1,1,0,
                0,1,0,0, 1,1,1,0,
                0,0,1,1, 0,1,1,0,
                0,0,1,0, 0,1,1,0,
                1,0,0,0, 0,1,0,0,
                0,1,0,1, 0,0,0,0,
                0,0,0,0, 0,0,0,1)
                                        (8c)
HALT            (c7)                    ()

Uses a Clock circuit to count up and output each character manually from a 16 byte Demuxer

Hippopotomonstrosesquipedalian, 6610 Bytes

hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquipedalian
hippopotomonstrosesquipedalian
pneumonoultramicroscopicsilicovolcanoconiosis

The name of the programming language says it all.

Compiler

c=""
p=input("What is the file path of the Hippopotomonstrosesquipedalian programme you want to run (including disk name)?\n")
f=open(p,"r")
r=f.readlines()
for x in range(0,len(r)):
    if r[x]=="pneumonoultramicroscopicsilicovolcanoconiosis" or r[x]=="pneumonoultramicroscopicsilicovolcanoconiosis\n":
        c=c+"1"
    elif r[x]=="hippopotomonstrosesquipedalian" or r[x]=="hippopotomonstrosesquipedalian\n":
        c=c+"0"
    else:
        raise SyntaxError("You cannot use a word other than 'hippopotomonstrosesquipedalian' or 'pneumonoultramicroscopicsilicovolcanoconiosis'. Is each word on its own line?")
d=int(c, 2)
l=(d.bit_length() + 7)//8
n=d.to_bytes(l,"big")
t=n.decode()
f.close()
g=open("programme_made_by_compiler_do_not_touch.py","w")
g.write(t)
g.close()
exec(open("programme_made_by_compiler_do_not_touch.py").read())
open("programme_made_by_compiler_do_not_touch.py").close()

Carbon, 62 bytes

package c api;fn Main()->i32{Print("Hello, World!");return 0;}

Try it Online!

Thanks to @Steffan for fixing this

Carbon is a new language by Google, supposed to be a successor to C++. Pretty boilerplatey language, even longer than Java.

Python 3, 20 bytes

print("Hello, World!")

Rol, 24 bytes

println("Hello, World!")

Rol is a new language I'm creating for the purposes of replacing Lua (because who likes Lua). I was gonna post this when the language was much more mature but I felt like reworking the CLI so I added an interpreter mode. That means you don't have to mess around with the stdlib and Lua linking and whatnot.

Once you download the jar from the releases, run it like this:

java -jar Rol-<version>.jar -i <input file>

Make sure -i is added otherwise it'll spit out a compiled Lua file.

Trilangle, 42 bytes

Prints no trailing newline.

"Hoo"!"o(oeooolo"""o"",Wr"!.looodo..o"""o@

Try it in the online interpreter: https://bbrk24.github.io/Trilangle/
The default program in the online interpreter is a variation on this that does print the trailing newline.

HP User RPL, 14 bytes

Thanks Corvalis

"Hello, World!"

dc, 16 bytes

One of my favorite calculator was missing, this should correct it.

[Hello, World!]p

Aheui (esotope), 92 bytes

붊볼벎봆뱞벽뱖벽브벓벍
부볃붊벋볾뱛벋따드먛뗘벎희별
밤뵗뵏뵒볾

Try it online!

Same code as below, but reuses four "data" chars (12 bytes) at the expense of two newlines. The compound vowel ㅚ does not have an assigned momentum, so the IP keeps going with the same speed and direction.

Aheui (esotope), ¹¹⁷ 102 bytes

밞바밤밣받밞밞밞밦밞바밝밣바박박밦밞받밞받밞발밣받뱔희밞땨몋드떠받볋

Try it online!

Another approach that is simpler and actually achieves the 2-char-per-output encoding. Each byte in Hello, World! can be encoded as \$9x+y+24\$ where \$x, y \in \{0,2,3,4,5,6,7,8,9\}\$. Here is the encoder. It also happened that the two additions were neatly merged into one character (once with +2 step and the other with -1), shaving off another char.

Aheui (esotope), 117 bytes

박밤밝발밞받밝밝밦밞밦발받박타받발따발밯밦밞밞받밞받밤받발따밞뱧희밣댜몋땨뎌벎

Try it online!

Aheui (esotope), 123 bytes

박박발타밝받발밞밝발밣받밣바받받밣타받밯밣받발밞발밞밦발밝뱧희밣댜몋땨뎌뱔텨뱔벽떠

Try it online!

Previous record: 144 by Sait2000

Since Aheui cannot push 10 or higher number at once, these programs try to minimize the cost of data by encoding each character into two numbers on the stack. If we subtract each character's charcode by 9 (the magic number), we get

63 92 99 99 102 35 23 78 102 105 99 91 24
7x9, 23x4, 11x9, 11x9, 17x6, 7x5, 23x1, 13x6, 17x6, 15x7, 11x9, 13x7, 12x2

And then subtract 8 from the larger number of each pair to get

-1 9 15 4 3 9 3 9 9 6 -1 5 15 1 5 6 9 6 7 7 3 9 5 7 4 2

Each occurrence of 15 or 1 adds 3 commands; the rest can be pushed in one. Then the loop is essentially

loop {
  add 8 (if stack is empty, halt)
  mul
  add 9; print as char
}

The second program is written in the same way, but using 23 as the magic number instead.

Whitespace, 192 150 146 bytes

Whitespace only needs spaces, tabs and linefeeds while other characters are ignored.
Which can be troublesome to display on here.
So in the code below the spaces & tabs were replaced.
And a ';' was put in front of the linefeeds for clarity.
To run the code, first replace . and > by spaces and tabs.

...;
..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
.;
.;
>.>;
...>>.>.>>;
>...>;
..;
.;
;
;
..>;
;
;
;

Try it online!

Hexdump of code

00000000: 2020 200a 2020 0909 2020 0920 0920 0a20
00000010: 2009 0909 090a 2020 2009 0a20 2020 0909
00000020: 090a 2020 2009 2020 0a20 2009 0920 0920
00000030: 200a 2020 0909 2020 0920 0909 0a20 2009
00000040: 0909 0909 0909 0a20 2020 0920 200a 2020
00000050: 2009 0a20 0a20 2020 0909 0920 0a20 2009
00000060: 0920 2020 0909 0a0a 2020 0a20 0a20 0a09
00000070: 2009 0a20 2020 0909 2009 2009 090a 0920
00000080: 2020 090a 2020 0a20 0a0a 0a20 2009 0a0a
00000090: 0a0a

Whitespace assembly code:

push 0      ;null
push -74    ;! chr(33)
push -7     ;d chr(100)
push 1      ;l chr(108)
push 7      ;r chr(114)
push 4      ;o chr(111)
push -20    ;W chr(87)
push -75    ;  chr(32)
push -63    ;, chr(44)
push 4      ;o
push 1      ;l
dup         ;l
push -6     ;e chr(101)
push -35    ;H chr(72)
p:
 dup jumpz e
 push 107 add printc
 jump p
e:
 exit

Remarks:

I had to write a program just to calculate that adding 107 gives the optimal golf for the sentence. Since the bytesize that an integer takes in the code changes. : 4+int(abs(log2($n)))
The code will still run without the "e:" label & exit part on whitespace.kauaveel.ee. But that could make the whitespace code invalid on other whitespace compilers. So those bytes weren't golfed out from the solution.

It Should Be Noted That

As Kevin Cruijssen pointed out in the comments, by allowing an "exit by error" as per meta, the Whitespace can be golfcoded more to 126 characters.

..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
...>>.>.>>;
>...>;
..;
.;
;

Try it online!

Assembly:

push -74
push -7
push 1
push 7
push 4
push -20
push -75
push -63
push 4
push 1
dup
push -6
push -35
label_0:
push 107
add 
printc
jmp label_0

C, 30 Bytes

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

Try it online!

Fairly vanilla, but I can't think of a commonly compilable way to do it any shorter (unless maybe some kind of raw asm trick might work?). Still, beats most esolangs!

Haystack, 17 Bytes

Haystack is a 2D programming language that executes until it finds the needle in the haystack |, all while performing stack-based operations. All programs start from the top left corner, and can use the directional characters ><^v to move around the program. Direction is inherited, so you do not need to keep using > to go right, direction will only change when it hits a different directional character.

By default, the interpreter reads from the top left going right, so we can just put "Hello, World!" onto the stack, use o to print it, then place the needle to finish executing.

"Hello, World!"o|

Try it online!

Bonus: A more exciting version:

v      >;+o|
v      "
v      !
v      d
v      l
v      r
>>"Hello, ">>>v
       W      v
       "      v
       ^<<<<<<<

Java, 79

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

Try it online!

Earlier versions of Java may allow you to use a static block (51 bytes), but currently I don't know of a way to bypass the main method.

Chef, 465 bytes

H.

Ingredients.
72 l h
101 l e
108 l l
111 l o
44 l C
32 l S
87 l w
114 l r
100 l d
33 l X

Method.
Put X into mixing bowl.Put d into mixing bowl.Put l into mixing bowl.Put r into mixing bowl.Put o into mixing bowl.Put w into mixing bowl.Put S into mixing bowl.Put C into mixing bowl.Put o into mixing bowl.Put l into mixing bowl.Put l into mixing bowl.Put e into mixing bowl.Put h into mixing bowl.Pour contents of the mixing bowl into the baking dish.

Serves 1.

Try it online!

Tested with the Ruby interpreter. Makes alphabet soup.

I tried to be as compliant to the original spec as I could, so even though the interpreter I used lets you drop the thes in the Pour contents instruction, I haven't done so.

The mixing bowl is pretty expensive, so there might be a better approach. I tried using base conversion to encode the message, but unfortunately the spec doesn't clarify whether Divide uses integer or floating point division, and the interpreter I have uses the latter. There's also no modulo operator, which doesn't help either.

MarioLANG, 259 249 242 240 235 bytes

+>+>)+)+)+++)++++((((-[!)>->.
+"+"===================#+".")
+++!((+++++++++)++++++)<.---+
++=#===================")---.
++((.-(.)).+++..+++++++.<---
 !+======================---
=#>++++++++++++++.).+++.-!>!
  =======================#=#

Try it online!

This has been tested in the Ruby implementation.

After obfuscating "Hello, World!" in MarioLANG I looked into golfing it a bit. The above is the shortest I have found so far.

As before I started from a Brainfuck solution which sets four cells to the nearest multiple of 10 to the characters He, and space and converted it to MarioLANG. You can then shorten the code a bit by making use of the auxiliary floor in the loop which almost halves the width of the loop. Note that the bottom is only executed one time less than the top, so you don't get exact multiples of the initial counter in all 4 cells any more.

Finally, I wanted to make use of the wasted space in front of the loop, so I added a bunch of elevators to make use of the vertical space there. And then I realised that I could fold the code after the loop (see previous revision) below the loop to make use of some more vertical space, which saved five more bytes.

This is likely still far from perfect, but it's a decent improvement over the naive solution, I think.

Metagolf

Time for some automation...

I have started setting up a solver in Mathematica to find an optimal solution. It currently assumes that the structure of the code is fixed: counter set to 12, 4 cells for printing, with the fixed assignment to He,<space> and the same order of those cells. What it varies is the number of +s in the loop as well as the necessary corrections afterwards:

n = 12;
Minimize[
 {
  3(*lines*)+
   12(*initialiser base*)+
   Ceiling[(n - 6)/2] 3(*additional initialiser*)+
   8(*loop ends*)+
   18(*cell moves*)+
   26(*printing*)+
   43*2(*steps between letters in one cell*)+
   -2(*edge golf*)+
   4 Max[4 + a + d + g + j + 2 Sign[Sign@g + Sign@j] + 2 Sign@j + 2,
     4 + b + e + h + k + 2 Sign[Sign@h + Sign@k] + 2 Sign@k] +
   2 (Abs@c + Abs@f + Abs@i + Abs@l),
  a >= 0 && d >= 0 && g >= 0 && j >= 0 &&
   b >= 0 && e >= 0 && h >= 0 && k >= 0 &&
   n*a + (n - 1) b + c == 72 &&
   n*d + (n - 1) e + f == 101 &&
   n*g + (n - 1) h + i == 44 &&
   n*j + (n - 1) k + l == 32
  },
 {a, b, c, d, e, f, g, h, i, j, k, l},
 Integers
 ]

It turns out, that for an initial counter of 12 my handcrafted solution is already optimal. However, using 11 instead saves two bytes. I tried all counter values from 6 to 20 (inclusive) with the following results:

6: {277,{a->7,b->6,c->0,d->16,e->1,f->0,g->0,h->9,i->-1,j->0,k->6,l->2}}
7: {266,{a->6,b->5,c->0,d->11,e->4,f->0,g->2,h->5,i->0,j->0,k->5,l->2}}
8: {258,{a->2,b->8,c->0,d->3,e->11,f->0,g->5,h->0,i->4,j->4,k->0,l->0}}
9: {253,{a->8,b->0,c->0,d->5,e->7,f->0,g->2,h->3,i->2,j->0,k->4,l->0}}
10: {251,{a->0,b->8,c->0,d->3,e->8,f->-1,g->4,h->0,i->4,j->3,k->0,l->2}}
11: {240,{a->1,b->6,c->1,d->1,e->9,f->0,g->4,h->0,i->0,j->3,k->0,l->-1}}
12: {242,{a->6,b->0,c->0,d->6,e->3,f->-4,g->0,h->4,i->0,j->0,k->3,l->-1}}
13: {257,{a->1,b->5,c->-1,d->6,e->2,f->-1,g->3,h->0,i->5,j->0,k->3,l->-4}}
14: {257,{a->1,b->4,c->6,d->0,e->8,f->-3,g->3,h->0,i->2,j->2,k->0,l->4}}
15: {242,{a->1,b->4,c->1,d->3,e->4,f->0,g->1,h->2,i->1,j->2,k->0,l->2}}
16: {252,{a->0,b->5,c->-3,d->4,e->2,f->7,g->0,h->3,i->-1,j->2,k->0,l->0}}
17: {245,{a->4,b->0,c->4,d->5,e->1,f->0,g->0,h->3,i->-4,j->0,k->2,l->0}}
18: {253,{a->4,b->0,c->0,d->1,e->5,f->-2,g->2,h->0,i->8,j->0,k->2,l->-2}}
19: {264,{a->0,b->4,c->0,d->5,e->0,f->6,g->2,h->0,i->6,j->0,k->2,l->-4}}
20: {262,{a->0,b->4,c->-4,d->5,e->0,f->1,g->2,h->0,i->4,j->0,k->2,l->-6}}

Note: This solver assumes that the linear code after the loop is all on the top line, and the above code is that solution folded up. There might be a shorter overall solution by making the solver aware of the folding, because now I get 3 more +s in the first part for free, and the next 4 instructions would cost only 1 byte instead of 2.

Seed, 6016 4234 4203 bytes

20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793

Try it online! The resulting Befunge-98 program (based on this) is

"9!dlroW ,olleH"ck,@

Try it online!

Homespring, 58 bytes

Universe net hatchery Hello,. World!  powers a b snowmelt 

Try it online!

The trailing space is significant.

Let me tell you a story. There was once a power plant which powered a nearby salmon hatchery. The salmon hatchery hatched a young homeless salmon which embarked on a journey upriver to find a spring. It did find such a spring, with the poetic name "Hello, World!", where it matured and spawned a new young salmon. Both fish now swam downstream, in search of the wide ocean. But just short of the mouth of the river, there was a net in the river - the mature fish was caught and only the young one managed to slip through and reached the ocean and the rest of the universe. In the meantime, the hatchery had hatched more salmon which had travelled upstream as well and spawned and so on and so on.

However, vast amounts of melting snow had been travelling down a different arm of the river. And just after our first young salmon from the springs of "Hello, World!" has reached the ocean, the snowmelt hit the universe and... uh... destroyed it. And they lived happily ever after... or I guess they didn't.

Those were actually the semantics of the above program. Homespring is weird.

Functional(), ¹³⁹ 129 bytes

0,1,=,:(W,& a(>(a(:(Z,&()(W()0)))),W))0 Z Z()1()1 W()W()>()W()>()> >()>()W()1()0()0()Z W 1()1()1()> >()> Z W 1()W()>()Z W()1()0 Z

Try it online!
Try the 139B version online!

Piet, 84 codels

28x3, here shown with codel width 10.

Created with PietDev (zip), tested with npiet. The layout of the program is the following:

Yellow fill indicates codels where the path overlaps, orange fill indicates codels which must be the same color, for purposes of control flow.

To aid in the creation of this, I wrote a rudimentary interpreter for a stack-based language with piet-like commands, which I have dubbed "pasm" (source). The output from this interpreter (with this input) is the following:

    1 nop     blu1 []
    4 push 3  blu2 [3]
    5 dup     grn2 [3, 3]
    6 add     cyn2 [6]
    7 dup     ylw2 [6, 6]
    8 mul     grn1 [36]
    9 dup     red1 [36, 36]
   10 dup     blu1 [36, 36, 36]
   11 add     mgn1 [36, 72]
H  12 putc    blu0 [36]
   15 push 3  blu1 [36, 3]
   16 sub     mgn2 [33]
   17 dup     cyn2 [33, 33]
   20 push 3  cyn0 [33, 33, 3]
   21 mul     blu2 [33, 99]
   22 push 1  blu0 [33, 99, 1]
   23 add     mgn0 [33, 100]
   24 dup     cyn0 [33, 100, 100]
   25 push 1  cyn1 [33, 100, 100, 1]
   26 add     blu1 [33, 100, 101]
e  27 putc    cyn0 [33, 100]
   28 dup     ylw0 [33, 100, 100]
   32 push 4  ylw1 [33, 100, 100, 4]
   33 dup     mgn1 [33, 100, 100, 4, 4]
   34 add     red1 [33, 100, 100, 8]
   35 add     ylw1 [33, 100, 108]
   36 dup     mgn1 [33, 100, 108, 108]
l  37 putc    blu0 [33, 100, 108]
   38 dup     grn0 [33, 100, 108, 108]
l  39 putc    ylw2 [33, 100, 108]
   40 dup     mgn2 [33, 100, 108, 108]
   43 push 3  mgn0 [33, 100, 108, 108, 3]
   44 add     red0 [33, 100, 108, 111]
   45 dup     blu0 [33, 100, 108, 111, 111]
o  46 putc    cyn2 [33, 100, 108, 111]
   47 dup     ylw2 [33, 100, 108, 111, 111]
   48 dup     mgn2 [33, 100, 108, 111, 111, 111]
   53 push 5  mgn0 [33, 100, 108, 111, 111, 111, 5]
   54 div     ylw0 [33, 100, 108, 111, 111, 22]
   55 dup     mgn0 [33, 100, 108, 111, 111, 22, 22]
   56 add     red0 [33, 100, 108, 111, 111, 44]
   57 dup     blu0 [33, 100, 108, 111, 111, 44, 44]
,  58 putc    cyn2 [33, 100, 108, 111, 111, 44]
   59 dup     ylw2 [33, 100, 108, 111, 111, 44, 44]
   60 add     grn2 [33, 100, 108, 111, 111, 88]
   64 push 4  grn0 [33, 100, 108, 111, 111, 88, 4]
   65 dup     red0 [33, 100, 108, 111, 111, 88, 4, 4]
   66 mul     ylw2 [33, 100, 108, 111, 111, 88, 16]
   67 dup     mgn2 [33, 100, 108, 111, 111, 88, 16, 16]
   68 add     red2 [33, 100, 108, 111, 111, 88, 32]
   69 putc    mgn1 [33, 100, 108, 111, 111, 88]
   70 push 1  mgn2 [33, 100, 108, 111, 111, 88, 1]
   71 sub     red0 [33, 100, 108, 111, 111, 87]
W  72 putc    mgn2 [33, 100, 108, 111, 111]
o  73 putc    blu1 [33, 100, 108, 111]
   76 push 3  blu2 [33, 100, 108, 111, 3]
   77 add     mgn2 [33, 100, 108, 114]
r  78 putc    blu1 [33, 100, 108]
l  79 putc    cyn0 [33, 100]
d  80 putc    grn2 [33]
!  81 putc    ylw1 []

No pointer, switch, or roll commands are used. No codels are wasted either; in fact two are reused.

ELF (x86/x64, Linux), 86 bytes

00000000: 7f45 4c46 b001 b20e 488d 3539 0000 003d  .ELF....H.59...=
00000010: 0200 3e00 89c7 eb18 0100 0000 0500 0000  ..>.............
00000020: 1800 0000 0000 0000 1800 0000 0500 0000  ................
00000030: 0f05 29d0 973d 3800 0100 b03c 0f05 0000  ..)..=8....<....
00000040: 0100 b03c 0f05 0000 4865 6c6c 6f2c 2077  ...<....Hello, w
00000050: 6f72 6c64 210a                           orld!.

Try it online!

Fig, \$9\log_{256}(96)\approx\$ 7.408 bytes

D'!>N]JyR

Try it online!

Gaia, 14 bytes

“Hello, World!

Try it online!

Strange that there wasn't a Gaia answer to this challenge yet, given that there's so many answers.

Grocery List, 98 79 bytes

H

w
nnn
d
c
c
z
f
v
d
v
l
v
r
v
o
v
W
n
b
s
v
X
nn
d
v
o
v
l
c
v
e
v
H
l
p
e
t

Save in a file then use this Python interpreter to run the specified program.

Cognate, 20 bytes

Print"Hello, World!"

Attempt This Online!

x86/x86_64 on Linux, 34 32 31 bytes

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

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

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

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

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

EDIT: Fixed TIO link.

SunSip -w -n, 24 bytes

(just means suppress warnings and no newlines)

set to "Hello, World
out

A big fat 24 bytes.

Syntax highlighted:

Knight, 16 bytes

O"Hello, World!"

Objective-Java*#++--.NETScriptnotation.sh, 22 bytes.

"Hello, World!".pdf.txt

Try it online!

How it works:

"Hello, World!".pdf     # Pushes "Hello, World!" to the stack.
                   .txt # Print the top item on the stack.

This is a stack-based esolang that I created that uses file extensions for commands.

Trianguish, 187 bytes

00000000: 0a04 10c3 0201 40d9 1020 1403 a040 4d0e
00000010: 2060 4d11 040b 003c 050e 204d 0203 c027
00000020: 060c 5107 106c 1040 4d0e 2050 c310 2028
00000030: 03f0 6074 1104 10c3 0502 c04e 0203 c027
00000040: 0611 0710 c510 404d 0e20 50e0 1020 2803
00000050: a060 2f10 7107 7105 0e20 4d04 10c3 0203
00000060: c027 0710 2310 2028 03a0 404d 0e20 50c3
00000070: 1060 5d11 0203 c027 050e 204d 0410 c307
00000080: 1077 1040 4d0e 2020 2803 a050 c310 607a
00000090: 1105 0e20 4d02 03c0 2704 10c3 0710 7410
000000a0: 404d 0e20 2028 03f0 50c3 1060 6b11 0202
000000b0: 9105 0e20 4d07 1024 1050 c2            

Try it online!

Trianguish is my newest language, a cellular automaton sort of thing which uses a triangular grid of "ops" (short for "operators"). It features self-modification, a default max int size of 216, and an interpreter which, in my opinion, is the coolest thing I've ever created (taking over forty hours and 2k SLOC so far).

This program consists of a central "spine" of wires and splitters, which transmits a 1-tick pulse of non-NIL data, and a number of "nodes" which print one character of the string as the pulse passes them.

At the start of the "spine" is a 1-tick pulse generator, one of the most basic, and important, applications of Trianguish's self-modification:

In this case, a 0 constant is used, as the actual number sent along doesn't matter, since it's used purely for timing.

Each "node" along the program consists of a T-switch, essentially a transistor, which permits an ASCII character code to flow through it for exactly one tick as the initial 1-tick pulse passes by. These character codes are produced by S-builders, which read the internal representation of an adjacent op, which in this case are tuned to match the correct characters. Only one node is different from the rest, that being the third, which instead of printing a single l splits the signal into two and prints both simultaneously. This also requires an additional delay for the next character.

Stack Cats, 94 + 3 = 97 bytes

(^_^_[>_[_*:>^]<^[>+:^[_!:+_+:>-!^_!]<:_^_I_+>_]<:_I_+:>_I^+>_I_+*-!*>+![+]+_!_-^+_)*_:_-^_!_:

Needs to be run with the -m switch, so +3

Try it online!

I'm sure there're still a lot of bytes which can be golfed, but this is the best I could think of so far.

Due to the reversibility of Stack Cats, I found it easier to think about the code in reverse - instead of thinking about how to turn the empty string into "Hello, World!", we want to think about how to consume the string "Hello, World!" from the stack.

I won't explain in detail what the code does, but it doesn't use any complicated tricks, and you can get a good idea by running it with the -D flag on the string "Hello, World!", or by pasting the code in the parenthesis in this site I made to help me create it, and typing slowrun() in the console. I found the code to create 100 33 8 by going over all programs under length 12, running them on 0 0 -1, and calculating the result's distance to 100 33 8 with BFS, and also used BFS to find what numbers can be converted to others with short code (for example converting 72 to 8 with 101, or converting 87 to -8 using 111).

Flobnar, 34 bytes

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

Try it online!

(Previous record: 41)

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

@    Start the program

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

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

Verbosity v2, 87 bytes

For some reasons, at least in the TIO's implementation it doesn't require the import statements...

outpt=OutputSystem:NewOutput<DEFAULT>
OutputSystem:DisplayAsText<outpt;"Hello, World!">

Try it Online!

Note: the name outpt is because variables name must be at least 5 characters long.

CATHY, 175 bytes

catHYcAthycAthYcAthYcaTHycathycAthYcAthYcAthycatHycaTHycaThYcaTHycathYcatHycatHYcaTHycaTHYcAthycathYcatHycatHYcatHycatHYcatHYcatHYcatHYCatHycathYcathYcaThYCAthyCATHycATHycAtHy

Try it Online! -90 thanks to Steffan.

CATHY is a joke language based on a certain spam post. In normal form:

389960998265612367812323333;115τCƒ+

It pushes a huge integer, then converts to base 115 and charcodifies.

Perhaps --verbose, 14 bytes

"Hello, World!

Positionally, 394 bytes

/           > \


  -
>    "!dlrow!" v
        v      <

   v  \ \   ^

  1


      
   ~

  ^           /
  <   \



      $ >    ",olleH "    .       .       .       .       .       .       .   $   .   $   .   $   .   $   .   $   .       .    v
                                                                                                                              ;<

   < >  \
      \

Try It Online!

This is so cursed. I don't really understand how it works, but it does.

Cubestack, 65 bytes

S R2 R R2 f2 r R r R r r R' L2 R B2 R2 u r r r L r R R2 f' R b S'

Try it online!

Cubestack is a (useless) stack-based esolang that only uses moves on a Rubiks Cube. See the repository on GitHub for more information.

A Language Programmed While Listening to Godspeed You! Black Emperor, 93 bytes

charms 72. 101. 108. 108. 111. 44. 32. 119. 111. 114. 108. 100. 33. 10﹔
print﹔
give up﹔

This is an esolang, and the goal of the language was to make it as annoying as possible to program.

Your, 4 bytes

your

This is a weird esolang, basically the number of "your" in your code will yield a different output.

A very long language name that is very weird and yeah, this is your but its this, 80 bytes.

A very long language name that is very weird and yeah, this is your but its this

Pyscript, 22 15 bytes

Cheat answer:

'Hello, World!'

Pyscript will behave pretty much like PHP, it will behave just like an interactive terminal. So you if supply a string to the interpreter, it will output the string itself to the rendered html document.

Appropriate answer (22 bytes like Python 3):

print("Hello, World!")

Test it crafting the following HTML file, serving it and rendering with a web browser:

Cheat answer:

<script defer src="https://pyscript.net/alpha/pyscript.js"></script><py-script>'Hello, World!'</py-script>

Appropriate answer:

<script defer src="https://pyscript.net/alpha/pyscript.js"></script>
<py-script>
print("Hello, World!")
</py-script>

ABC, 21 bytes

WRITE "Hello, World!"

Try it online!

Scratch, 33 bytes

when gf clicked
say[Hello, World!

MSWLogo, 16 bytes

pr[Hello, World!

Brainfuck, 78 bytes

Open-ended bounty: If anyone can improve this score, I will pass the bounty (+500) on to them. @KSab has found a 76 72 byte solution!

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

Try it online!

The first 28 bytes --<-<<+[+[<+>--->->->-<<<]>] initialize the tape with the following recurrence relation (mod 256):

\$f_n=171(-f_{n-1}-f_{n-2}-f_{n-3}+1)\$, with \$f_0=57, f_1=123,f_2=167\$

The factor of \$171\$ arises because \$3^{-1}=171 \pmod{256}\$. When the current value is translated one cell back (via <+>---) subtracting \$3\$ each time effectively multiplies the value by \$171\$.

At \$n=220\$ the value to be translated is zero, and the iteration stops. The ten bytes preceding the stop point are the following:

\$[130, 7, 43, 111, 32, 109, 87, 95, 74, 0]\$

This contains all of the components necessary to produce Hello, World!, in hunt-and-peck fashion, with minor adjustments.

I've also found an alternative 78 byte solution:

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

Try it online!

I consider this one to be better than the first for several reasons: it uses less cells left of home, it modifies less cells in total, and terminates more quickly.

More Detail

Recurrence relations have surprisingly terse representations in Brainfuck. The general layout is the following:

{...s3}<{s2}<{s1}[[<+>->{c1}>{c2}>{c3...}<<<]>{k}]

which represents:

\$f_n=c_1f_{n-1}+c_2f_{n-2}+c_3f_{n-3}+\cdots+k\$

with

\$f_0=s_1, f_1=s_2+c_1f_0+k,f_2=s_3+c_2f_0+c_1f_1+k,\text{etc.}\$

Additionally, the <+> may be changed to multiply the range by a constant without affecting the stop point, and a term may be added before the >{k} to shift the range by a constant, again without affecting the stop point.

Other Examples

Fibonacci Sequence

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

N-gonal Numbers

Triangular Numbers

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

Defined as \$f_n=2f_{n-1}-f_{n-2}+1\$, with \$f_0=0,f_1=1\$.

Square Numbers

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

Pentagonal Numbers

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

etc.

BF Crunch

I've published the code I used to find some of this solutions on github. Requires .NET 4.0 or higher.

Usage: bfcrunch [--options] text [limit]

Arguments
------------------------------------------------------------
  text              The text to produce.
  limit             The maximum BF program length to search for. If zero, the length of the
                    shortest program found so far will be used (-r). Default = 0

Options
------------------------------------------------------------
  -i, --max-init=#  The maximum length of the initialization segment. If excluded, the
                    program will run indefinitely.
  -I, --min-init=#  The minimum length of the initialization segment. Default = 14
  -t, --max-tape=#  The maximum tape size to consider. Programs that utilize more tape than
                    this will be ignored. Default = 1250
  -T, --min-tape=#  The minimum tape size to consider. Programs that utilize less tape than
                    this will be ignored. Default = 1
  -r, --rolling-limit
                    If set, the limit will be adjusted whenever a shorter program is found.
  -?, --help        Display this help text.

Output is given in three lines:

1. Total length of the program found, and the initialization segment.
2. Path taken, starting with the current tape pointer. Each node corresponds to one character of output, represented as (pointer, cost).
3. Utilized tape segment.

For example, the final result for bfcrunch "hello world" 70 -r -i23 is:

64: ++++[[<+>->+++++>+<<]>]
49, (45, 5), (44, 3), (45, 6), (45, 1), (45, 4), (42, 4), (43, 5), (45, 3), (45, 4), (46, 2), (44, 4)
32, 116, 100, 104, 108, 132, 0, 0, 132, 0

This corresponds to the full program:

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

Other Records

Hello, World!

Wrapping, 78 bytes:
Surpassed by @KSab (72)

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

or

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

Non-wrapping, 80 bytes (previously 92 bytes (mitchs)):
Surpassed by @KSab (76)

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

Hello, world!

Wrapping, 80 bytes:
Surpassed by @KSab (77)

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

Non-wrapping, 81 bytes (previously 92 bytes (hirose)):

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

hello, world!

Wrapping, 74 bytes:
Surpassed by @KSab (70)

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

Non-wrapping, 84 bytes:

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

Esolangs Version

Hello World!\n

Wrapping, 76 bytes:

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

This uses one cell left of home, and thus would be considered 77.

Non-wrapping, 83 bytes: