JavaScript (V8), 150 bytes, score: 1328 1246

print("H"+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]+"o,","Wo"+(!![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([][[]]+[])[!+[]+!+[]]+"!")

Try it online!

My first attempt was this:

print("Hello,","World!")

which gave a score of 1328. I encoded select portions of the code using JSFuck to get the above score of 1246.

Go, 61 48 bytes, score 2527 2401

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

Attempt This Online!

The boilerplate hello world, compressed onto 1 line.

• -13 bytes and -126 score from printing to STDERR instead.

Gema, 59 characters, score 858

\A=\110\145\154\154\157\054\040\127\157\162\154\144\041@END

(Doh. After all these years, now I discovered that Gema function names are case insensitive.)

Sample run:

bash-5.2$ gema '\A=\110\145\154\154\157\054\040\127\157\162\154\144\041@END'
Hello, World!

Try it online!

Vyxal, 4528 bytes, score 156

..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+..+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+C+

Try it Online!

. on its own represents 0.5, so this adds up a bunch of 0.5s, converts them to characters, then concatenates them together. This actually does better than using the builtin kH, which has a score of 179.

C# (.NET Core), 71 bytes (score 2563)

class a{static void Main(){System.Console.WriteLine("Hello, World!");}}

Try it online!

I'm just starting with C#, so maybe there's a way to do it even shorter

Grass, score 324, 623 bytes

wvwwWWwWWWwvWwwwwWWwWWWwWWWWwWWWWWwWWWWWWwWWWWWWWwWwwwwwwwwwwwwWWWWwWWWWWWWwWWWWWWWWWWWWWWwWWWWWWWWWWWwwWWWWWWWWWWwwWWWWWWWWWWWWwWWWWWWWWWWwwWWWWWWWWWWwwwwwwwWWWWWWWWWWWWWWwWWWWWWWWWWWWWWWWwWWWWWWWWWWWWWWWWWWWWWWwWWWWWWWWWWWWWWWWWWWwwWWWWWWWWWWWWWWWWWWwwWWWWWWWWWWWWWWWWWWwwwwwWWWWWWWWWWWWWWWWWWWWWwwWWWWWWWWWWWWWWWWWWWWWWWwWWWWWWWWWWWWWWWWWWWWWWWWWWwwwwwwwwwwwwwwwwwwwwwwwwwwwWwwwwwwwwwwwWWwwwwwwwWWWwwwwwwwWWWWwWWWWWwwwwwwwwWWWWWWwwwwwwwwwwwwwwwwwWWWWWWWwwwwwwwwwwwwwwwwwwwwwWWWWWWWWwwwwwwwwwwwwwwwwwWWWWWWWWWwwwwWWWWWWWWWWwwwwwwwwwwwWWWWWWWWWWWwwwwwwwWWWWWWWWWWWWwwwwwwwwwwwwwwwwwwWWWWWWWWWWWWWwwwwwwwwwwwwwwwwwwwwwwwwww

Bits, score: 97

There are only 2 distinct characters in Bits, 0 and 1. These have ASCII values of \$48\$ and \$49\$, so the score is \$97\$.

If you're interested, this is actually only 10 bytes (80 bits).

10010000001010011000011000011110111000111111010111001111010010001100000100011101

Explanation

1001000 // H
000101  // e
001100  // l
001100  // l
001111  // o
011100  // ,
011111  //  
1010111 // W
001111  // o
010010  // r
001100  // l
000100  // d
011101  // !
        // [implicitly joined and output]

Pascal, 1449

1. 2189: The boilerplate Hello World reads:

   program p(output); begin writeLn('Hello, World!') end.
   

2. 2080: Since Pascal is case-insensitive we can capitalize keywords and identifiers. This lowers the score because capital letters come before lower-case letters:

   PROGRAM P(OUTPUT); BEGIN WRITELN('Hello, World!') END.
   

3. 1706: Now, as some keywords are non-optional and our program needs definitely needs at least one string or char literal in conjunction with some write, we can reuse the preexisting letters in our Hello, World! string.

   ProGrAM P(oUTPUT); BeGIN WrITe('Hello, World!') eNd.
   

   The now lower-cased letters already appear as part of Hello, World!. Only H, l, , and ! are “new” letters which aren’t found in the rest of the program.
4. 1449: Let’s avoid any characters from set of ['H', 'l', ',', '!'] by using “preexisting” letters and the built-ins we can use with them. If we are running this program on a system using the ASCII character set as its base, we can use pred('I') to retrieve the value 'H' without writing a char literal 'H':

   ProGrAM P(oUTPUT); BeGIN WrITe(Pred('I')); WrITe('e'); WrITe(Pred(Pred(Pred('o')))); WrITe(Pred(Pred(Pred('o')))); WrITe('o'); WrITe(Pred(Pred('.'))); WrITe(' Wor'); WrITe(Pred(Pred(Pred('o')))); WrITe('d'); WrITe(Pred(Pred(Pred(Pred(Pred(Pred(''''))))))) eNd.
   

   This program merely requires an ISO standard 7185 “Standard Pascal” processor (level 0 sufficient). It has a total size of 216 bytes thus below the eight, uhh… whoops, one thousand byte limit.

Knight, 460 383 442 bytes, score 268 236 226

-32 score thanks to @Adam by utilizing A1

-10 score thanks to @emanresu A and @UnrelatedString by using E to EVAL O"Hello, World" instead of using O directly

E+++++++++++++++A+11+11+11+11+11+11+11+1+1A1A+11+11+11+1A1A+11+11+11+11+11+11+1+1+1+1+1+1A1A+11+11+11+11+11+11+11+11+11+1+1A1A+11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1A1A+11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1A1A+111A1A+11+11+11+11A1A+11+11+1+1+1+1+1+1+1+1+1+1A1A+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1A1A+111A1A+111+1+1+1A1A+11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1A1A+11+11+11+11+11+11+11+11+11+1A1A+11+11+11A1A+11+11+11+1A1

Characters used: E+A1

Try It Online!

(Code used to generate this Knight code: Try It Online!)

KonamiCode, 168 bytes (score 415)

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

Characters used: ^v<>()

Excel VBA (Immediate Window), 396 bytes, score 457

?CHR(11+11+11+11+11+11+1+1+1+1+1+1)+CHR(11+11+11+11+11+11+11+11+11+1+1)+CHR(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+CHR(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+CHR(111)+CHR(11+11+11+11)+CHR(11+11+1+1+1+1+1+1+1+1+1+1)+CHR(11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1)+CHR(111)+CHR(111+1+1+1)+CHR(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+CHR(11+11+11+11+11+11+11+11+11+1)+CHR(11+11+11)

Similar to the Excel answer. Uses 2 fewer unique characters.

Excel, 409 bytes, score 558

=CHAR(11+11+11+11+11+11+1+1+1+1+1+1)&CHAR(11+11+11+11+11+11+11+11+11+1+1)&CHAR(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)&CHAR(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)&CHAR(111)&CHAR(11+11+11+11)&CHAR(11+11+1+1+1+1+1+1+1+1+1+1)&CHAR(11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1)&CHAR(111)&CHAR(111+1+1+1)&CHAR(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)&CHAR(11+11+11+11+11+11+11+11+11+1)&CHAR(11+11+11)

Link to Spreadsheet

MATLAB, 15 Bytes (score 802)

'Hello, World!'

Deadfish~, 1 byte, score 119

w

Try it online!

Not so interesting

Ly, 378 bytes (score 309)

````````````````````````````````````````````````````````````````````````:o`````````````````````````````:o```````::oo```:o,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:o,,,,,,,,,,,,:o```````````````````````````````````````````````````````:o````````````````````````:o```:o,,,,,,:o,,,,,,,,:o,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,o

Try it online!

Uses four instructions, increment top of stack, duplicate top of stack, decrement top of stack, and print as a character.

 :,o`

Pyth, 430 bytes, score 191

++++++++++++C+++++++++++11 11 11 11 11 11 1 1 1 1 1 1C++++++++++11 11 11 11 11 11 11 11 11 1 1C+++++++++++++++++11 11 11 11 11 11 11 11 11 1 1 1 1 1 1 1 1 1C+++++++++++++++++11 11 11 11 11 11 11 11 11 1 1 1 1 1 1 1 1 1C111C+++11 11 11 11C+++++++++++11 11 1 1 1 1 1 1 1 1 1 1C++++++++111 1 1 1 1 1 1 1 1C111C+++111 1 1 1C+++++++++++++++++11 11 11 11 11 11 11 11 11 1 1 1 1 1 1 1 1 1C+++++++++11 11 11 11 11 11 11 11 11 1C++11 11 11

Try it online!

Nim, 387 bytes, score 601

ecHO cHR 11+11+11+11+11+11+1+1+1+1+1+1,cHR 11+11+11+11+11+11+11+11+11+1+1,cHR 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,cHR 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,cHR 111,cHR 11+11+11+11,cHR 11+11+1+1+1+1+1+1+1+1+1+1,cHR 11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1,cHR 111,cHR 111+1+1+1,cHR 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,cHR 11+11+11+11+11+11+11+11+11+1,cHR 11+11+11

Try it online!

Chars: ecHRO, +1

AWK, 57 bytes, score 1632

Escape sequences are in octal.

BEGIN{print"\110\145\154\154\157\54\40W\157r\154\144\41"}

Try it online!

Score count

Java (JDK), 468 bytes, score 1234

\u0063\u006c\u0061\u0073\u0073\u0020\u0041\u007b\u0070\u0075\u0062\u006c\u0069\u0063\u0020\u0073\u0074\u0061\u0074\u0069\u0063\u0020\u0076\u006f\u0069\u0064\u0020\u006d\u0061\u0069\u006e\u0028\u0053\u0074\u0072\u0069\u006e\u0067\u005b\u005d\u0061\u0029\u007b\u0053\u0079\u0073\u0074\u0065\u006d\u002e\u006f\u0075\u0074\u002e\u0070\u0072\u0069\u006e\u0074\u0028\u0022\u0048\u0065\u006c\u006c\u006f\u0020\u0057\u006f\u0072\u006c\u0064\u0021\u0022\u0029\u003b\u007d\u007d

Try it online!

Note: I'm stumped on how to make it have less score. Oracle really does make it hard to golf. Thanks to @ceilingcat for and halfing the score.

Julia, 107 bytes, score 815

print('i'-11-11-11,'p'-11,'n'-1-1,'n'-1-1,'p'-1,',',','-11-1,'n'-11-11-1,'p'-1,'r','n'-1-1,'p'-11-1,','-11)

characters used print('-1,)

Try it online!

Zsh, 464 bytes, score 552

Try it Online!       charset: <${(#)1+}

<<<${(#)$((11+11+11+11+11+11+1+1+1+1+1+1))}${(#)$((11+11+11+11+11+11+11+11+11+1+1))}${(#)$((11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1))}${(#)$((11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1))}${(#)$((111))}${(#)$((11+11+11+11))}${(#)$((11+11+1+1+1+1+1+1+1+1+1+1))}${(#)$((11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1))}${(#)$((111))}${(#)$((111+1+1+1))}${(#)$((11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1))}${(#)$((11+11+11+11+11+11+11+11+11+1))}${(#)$((11+11+11))}

Wolfram Language (Mathematica), 321 bytes, score 399

charset: \013456

\043\1333311\05313311\0531133\135\133\043\13311\0534011\0534031\135\133\043\1331343\05311354\135\13331\05341\054101\0544\053104\0544\053104\054111\05444\0541\05331\05443\05344\054111\054114\0544\053104\054100\05433\135\135\135\046\1330\133\1330\0540\135\135\133\116\141\155\145\163\133\135\133\133\043\135\135\135\046\135

Try it online!

I feel it's best to try to explain this one. First, Mathematica allows character inputs with octal triplets (From this point on, I'll be using my local copy), after decoding, looks like so

#[1000+31111][#[3304+11135][#[10000+13003][31+41,101,4+104,4+104,111,44,1+31,43+44,111,114,4+104,100,33]]]&[0[[0,0]][Names[][[#]]]&]

All of the addition is just to avoid getting a 2, 7, 8, or 9, which in octal have 2s and 7s, which are trivially avoidable, all the other characters are the minimum needed to get Names[]. When the actual functions are shown,

Print[FromCharacterCode[List[72,101,108,108,111,44,32,87,111,114,108,100,33]]]

Where all the functions are hidden inside a Names[][[1234]] so that they can all be numerically decided, but Names[], at minimum, needs \13456 to derive everything else, the 0 is needed to turn Names's string output into Functions, as 0[[0,0]] returns Symbol.

I know that after making this whole thing it can be golfed to do without 0, as the only time it comes up is in addition, inside the octal for the + symbol, and getting the symbol header, meaning that if 0 can be derived elsewhere then in the charset 0 can be switched to +, lowering the score by 5. All it would need is to not use commas inside list. The only function that I recall that can do this is the Append family, but calling Append instead of each comma makes the program over 2k in size.

In case you want to see how it was generated, I will put most of my code here

Perl 5, 386 bytes, score = 818

say chr 11+11+11+11+11+11+1+1+1+1+1+1,chr 11+11+11+11+11+11+11+11+11+1+1,chr 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,chr 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,chr 111,chr 11+11+11+11,chr 1+1+1+1+1+1+1+1+1+1+11+11,chr 11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1,chr 111,chr 111+1+1+1,chr 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,chr 11+11+11+11+11+11+11+11+11+1,chr 11+11+11

Try it online!

G*, 15 bytes, score = 914

p Hello, World!

2/9 of an esolang, 1 byte, score = 64

@

C (gcc), ^{344 \$\cdots\$ 254} 242 bytes, score ¹⁶²⁴ 1575

Lowered score by 49 thanks to Arnauld!!!

Saved 12 bytes thanks to ceilingcat!!!

h;t;u;i;a;main(c){u+=u=i+=i=a=c+c+c;t=u+u+u;putchar(putchar(t+t)+u+u+a+c+c);putchar(putchar(putchar(h=t+t+t))+a);putchar(t+i+c+c);putchar(u+u+i+c+c);putchar(t+t+u+a);putchar(h+a);putchar(h+i);putchar(h);putchar(t+t+u+u+a+c);putchar(u+u+i+a);}

Try it online!

Uses characters: ()+;=achimnprtu{}

naz, 732 bytes, score 372

1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o1a1a1a1a1a1a1a1o1o1a1a1a1o1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1o1s1s1s1s1s1s1s1s1s1s1s1s1o1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o1a1a1a1o1s1s1s1s1s1s1o1s1s1s1s1s1s1s1s1o1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1o

Uses 1, a, s and o.

Without the size restriction, naz -u could achieve a theoretical score of 257 by foregoing s.

C (gcc) -zexecstack -Wl,-e$ -nostartfiles on Linux x86-64, 876 914 bytes, score 798 293

$=1111+1111+1111+111+111-11-11-11-11+1+1+1;$$=1111111111+111111111-11111111+1111111+1111111-111111+1111+1111+111+111+111+111+111-11-11-11-11+1+1+1+1+1;$$$=111111+111111-11111-1111+111+111+111-11-1-1-1-1-1;$$$$=111111111+111111111+11111111+11111111+11111111+1111111+1111111+111111-1111-1111-1111-1111-111-111-111+11+11+11+11+1+1+1+1+1;$$$$$=1111111111+1111111111-111111111-111111111-111111111-111111111+11111111+11111111+11111111+11111111-1111111-1111111-1111111-111111-111111-111111+11111+11111-1111+111+111+11+1;$$$$$$=111111111+111111111+111111111+111111111+111111111-11111111-1111111-1111111-1111111-1111111-111111-111111+1111+1111+1111+1111+1111-111-111-111+11+11-1-1;$$$$$$$=1111111111+1111111111-111111111-111111111-111111111-111111111+11111111+11111111+11111111+11111111-1111111-1111111-111111-111111-111111-111111-111111-1111-1111-1111-1111-1111+11+11+11+11+1;$$$$$$$$=11111-1111-1111-111-111-111-11+1+1+1;

Try it online!

Charset: A[]={+,-1}; 1+-$=;

Same method as the previous answer, with even more hacking to supply a custom entry point named $ (which has the smallest ASCII value among a-zA-Z_$). Credit to this SO answer for identifying the flags and assembly setup to make this work. Also got a hint from ceilingcat's awesome linker hack to remove []{} from the code.

Assembly: (NASM syntax)

bits 64
global _start
_start:
  mov edx, 13
  pop rax
  push rax
  lea rsi, [rel s]
  pop rdi
  syscall
s: db "Hello, World!"

Uses the argc=1 set up on the stack to load the value 1 to rax and rdi. The instructions are slightly mixed up in order to get the minimal code length in C.

Here is the Python script that generates the "ones decomposition" from the xxd -i output (C include-style hex output) of the compiled binary.

C (gcc) -zexecstack on Linux x86-64, 891 bytes, score 1154

main[]={1111+1111+1111+111+111-11-11-11-11+1+1+1,1111111111-111111111-111111111+11111111-1111111-111111-111111-111111-111111+11111-1111-1111-1111-1111+111+111+111+11,1+1+1+1,111111111-11111111-11111111-1111111-1111111-1111111-1111111+111111+111111+111111+111111+11111+11111+11111+11111-111-111-111-111-111-11-11-11,1111111111+1111111111-111111111-111111111-111111111-111111111+11111111+11111111+11111111+11111111-1111111-1111111-1111111+111111+11111+11111+11111+11111-1111-111-111+11+11+11,1111111111+111111111+111111111+111111111+11111111+11111111-1111111-1111111-1111111-1111111-111111-111111-111111-111111-11111-11111-11111-11111-11111+1111+1111+1111+1111-111-111-111-11-1-1-1-1,1111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111-1111111-1111111-1111111-1111111+111111+111111+111111+11111+11111+11111+11111+11111-1111-1111-1111-1111-111+11-1-1-1-1-1,11+11+11};

Try it online!

Uses ceilingcat's minimal Turing-complete charset main[]={1+,};, plus - to meet the code length limit.

Assembly: (NASM syntax)

bits 64
global _start
_start:
  mov edx, 13
  lea rsi, [rel s]
  mov eax, edi
  syscall
s: db "Hello, World!"

Essentially calls write syscall once, and goes into arbitrary instructions formed by the string literal, causing segfault.

Erlang (escript), 439 bytes, score: 1706

Port of the 540 byte C answer. Unique characters:

main([])->o:fwrte1+,.

Which is of length 23, sum 1706.

main([])->io:fwrite([11+11+11+11+11+11+1+1+1+1+1+1,11+11+11+11+11+11+11+11+11+1+1,11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,11+11+11+11+11+11+11+11+11+11+1,11+11+11+11,11+11+1+1+1+1+1+1+1+1+1+1,11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1,11+11+11+11+11+11+11+11+11+11+1,11+11+11+11+11+11+11+11+11+11+1+1+1+1,11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,11+11+11+11+11+11+11+11+11+1,11+11+11]).

Try it online!

PHP, 13 bytes, score 802

Hello, World!

Try it online!

H🌍, 2 bytes, score 223

hw

Try it online!

Bash, 18 bytes, score 1005

echo Hello, World!

Try it online!

Rust, 35 bytes, Score: 1916

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

I don't know if you can get any shorter in Rust.

Help, WarDoq!, 1 byte, Score: 72

H

Try It Online!

C (gcc), 540 bytes, score 1563

main(){putchar(11+11+11+11+11+11+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+1+1);putchar(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+11+1);putchar(11+11+11+11);putchar(11+11+1+1+1+1+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+11+1);putchar(11+11+11+11+11+11+11+11+11+11+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+1);putchar(11+11+11);}

Try it online!

This is just a straightforward solution that prints the ASCII code of each character in turn, like some of the other solutions here. I'm not aware of any tricky way to reduce the score in C.

dc, ^{106 652 192} 428 bytes, score ^{332 272 272} 204

11 11+11+11+11+11+1+1+1+1+1+1+P11 11+11+11+11+11+11+11+11+1+1+P11 11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+P11 11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+P11 11+11+11+11+11+11+11+11+11+1+P11 11+11+11+P11 11+1+1+1+1+1+1+1+1+1+1+P11 11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1+P11 11+11+11+11+11+11+11+11+11+1+P11 11+11+11+11+11+11+11+11+11+1+1+1+1+P11 11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+P11 11+11+11+11+11+11+11+11+1+P11 11+11+P

Try it online!

4 characters used: +1P and the space character.

Malbolge, 71 bytes, 3963 points

(=<`#9]=}5YXy1Uvv-Q+q)Mn&Jk#j!EC$dc.?}_<)L'8%oXW2qj|Q@yx+iba'Hd]\E!YX|z

Try it online!

Uses the following unique characters

!#$%&'()+-.12589<=?@CEHJLMQUWXY\]_`abcdijknoqvxyz|}

HQ9+, 1 byte, score 72

H

There is no TIO implementation for HQ9+.

05AB1E, score: 282 (251 bytes)

0>>>0>>>>>>>>>0>0>>>0>>>>>>>>0>>>>>0>>>0 0>>>>>>0>>>>>>>>0>>>>>>>>0>>>>0>>>>>>>0>>0 0>>>>>>>0>>>0 0>>>>>0>>>>>>>>>0>>0>>>0>0>>>>>>0 0>>>>>>>J 0>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>B

Try it online.

Five characters used: 0> JB

Explanation:

1. First we construct the number 39138530688472073059231607. We do this per digit, by pushing a 0 and increasing it by 1 per >, after which the entire stack of digits is joined together with J.
2. Then it pushes another 0 with 107 >s to get the number 107.
3. After which it will convert 39138530688472073059231607 to base-107 with B, which is "Hello, World!".

Gol><>, 234 bytes, score 259

llllllll+++l+++++lllllllllllll+++++l++++++++llllllllllll+++++l+l+++++++llllllllllll+++l+++++++++lllllllllll+++l++++++++lllllll++ll++l+++++llll+++l+l+lll++l+$llllllll++++++l++l+llllll+++lll+++++llllllll+++++++lll++l+l+l+llllll++++l++$H

Try it online!

Used characters: l (length of stack), + (add top two numbers), $ (swap top two numbers), H.

$ was needed because some characters (space, H) were impossible to create at that specific stack height; it is cheaper than any number literal (minimum being 0).

Gol><>, 182 bytes, score 315

ssP0ssssssPPPP0ssssssPPPPPPPPPPPP0sssssssPP0ssssssPPPPPPPPPPPPPPP0sssssPPPPPPP0ss0ssPPPPPPPPPPPP0ssssssPPPPPPPPPPPPPPP0ssssssPPPPPPPPPPPP0ssssssPPPPPPPPPPPP0ssssssPPPPP0ssssPPPPPPPPH

Try it online!

Used characters: 0 (push zero to the stack), s (add 16 to top), P (increment top), H (halt and print everything on the stack as characters).

Python 2, 574 bytes, score 564

exec"%c"%(111+1)+"%c"%(111+1+1+1)+"%c"%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+"%c"%(11+11+11+11+11+11+11+11+11+11)+"%c"%(111+1+1+1+1+1)+"%c"%(11+11+11+1+1+1+1+1+1)+"%c"%(11+11+11+11+11+11+1+1+1+1+1+1)+"e%c"%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+"%c"%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+"%c"%111+"%c"%(11+11+11+11)+"%c"%(11+11+1+1+1+1+1+1+1+1+1+1)+"%c"%(11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1)+"%c"%111+"%c"%(111+1+1+1)+"%c"%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+"%c"%(11+11+11+11+11+11+11+11+11+1)+"%c"%(11+11+11)+"%c"%(11+11+11+1+1+1+1+1+1)

Try it online!

Used characters: exc"%(1+)

Constructs the string print'Hello, World!' using the characters "%c(1+), then execs it. Using the raw print with any single extra character costs more than this.

Brain-Flak, 618 bytes, score 265

((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())()()()()()()()())()()()()()())[()()()])[()()()()()()()()()()()()()()()()()()()()()()()()])(((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())()()()()()()()()()()()())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())[()()()]))[()()()()()()()])[()()()()()()()()()()()()()()()()()()()()()()()()()()()()()])

Try it online!

Used characters: ()[]

Uses () (one), (...) (sum and push), [...] (negate). Can definitely be shorter by using [] (stack height) but it's not the point of the challenge (as long as the code is under 1000 bytes). Looks like the program can't fit into 1000 bytes using only () and (...).

brainfuck, 134 score

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.-------------------------------------------------------------------.

Try it online!

Alas, could have scored 89 if not for the 1000 character limit.

Boolfuck, 102 score

;;;+;+;;+;+;+;+;+;+;;+;;+;;;+;;+;+;;+;;;+;;+;+;;+;+;;;;+;+;;+;;;+;;+;+;+;;;;;;;+;+;;+;;;+;+;+;+;+;+;;;;+;+;;+;;+;+;;+;;;+;;;+;;+;+;;+;;;+;+;;+;;+;+;+;;;;+;

Try it online!

"Standard".

Stuck, 0 bytes, score 0

An empty program prints "Hello, World!"

Just as suggested in the comments, Stuck wins!

CJam, 652 bytes, score 120

'))))))))))))))))))))))))))))))))')))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))')))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))''(((((((')))))))))))))))))))))))))))))))))))))))))))))))')))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))''((((((

Try it online!

Uses ')(.