# [Stuck](https://esolangs.org/wiki/Stuck), 0 bytes

An empty program prints `Hello, World!` in [Stuck](https://esolangs.org/wiki/Stuck).

# [Actually](https://github.com/Mego/Seriously), 1 byte
The program is a built-in in Actually.

    H

[Try it online!](https://tio.run/##S0wuKU3Myan8/9/j/38A "Actually – Try It Online")

# [Keg], 8 bytes

    «H%c¡|,!

[Try it online!][TIO-k6320gnp]

[Keg]: https://github.com/JonoCode9374/Keg
[TIO-k6320gnp]: https://tio.run/##y05N////0GoP1eRDC2t0FP//BwA "Keg – Try It Online"

# TeX, 13 (or 17?) bytes

Since every normal text is printed directly in TeX the shortest "function" is:

```tex
Hello, World!
```

A complete script (one needs to end the run to actually get the output file):

```tex
Hello, World!\bye
```

Output is printed to PDF if you use `pdftex`.

# [Golfscript](https://http://www.golfscript.com/), 15 bytes

```
"Hello, World!"
```

I spent a good amount of time trying to find a more efficient way, but the best I could do was in the low-twenties. Guess this will have to do!

# [Python 2](https://docs.python.org/2), 20 bytes

```python
print"Hello, World!"
```

[Try it online!][TIO-k5u39359]

[TIO-k5u39359]: https://tio.run/##K6gsycjPM/r/v6AoM69EySM1JydfRyE8vygnRVHp/38A "Python 2 – Try It Online"

# C, 30 bytes (program)

Using gcc 9.2.0.

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

[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPQ7O6oLSkWEPJIzUnJ19HITy/KCdFUUnTuvb/fwA)

# [ABC-assembler](https://hdl.handle.net/2066/113882), 39 bytes

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

This is a full program in ABC-assembler ([Clean](https://clean.cs.ru.nl/Clean)'s IL) as described in [this paper](https://hdl.handle.net/2066/113882).

[Try it online!](https://tio.run/##S0xK1k0sLk7NTcpJLfr/X6@4JLGoRKGYq5iLs6AoM69EQckjNScnX0chPL8oJ0VRiYszIzGn5P9/AA "ABC-assembler – Try It Online")

# [Clean](https://clean.cs.ru.nl/Clean), 15 bytes

```clean
"Hello, World!"
```
This is an unnamed function taking no arguments and returning a string.  
Due to Clean's use of currying, this is equivalent to a string literal.

It has the same type signature as a named function:
```clean
f :: String
f = "Hello, World!"
```
A superfluous arrow can be added to reinforce this:
```clean
f :: -> String
f = "Hello, World!"
```

As a full program it's 21 bytes, plus a 9-byte-minimum file header:
```clean
Start="Hello, World!"
```
[Try it online!](https://tio.run/##S85JTcz7n5ufUpqTqpCbmJn3P7gksajEVskjNScnX0chPL8oJ0VR6f//f8lpOYnpxf91kwA "Clean – Try It Online")

# [PHP](https://php.net), ~~28~~ 13 bytes

Seeing as:


> PHP echos everything by default outside the <? tags


```php
Hello, World!
```

[Try it online!](https://tio.run/##K8go@P/fIzUnJ19HITy/KCdF8f9/AA "PHP – Try It Online")

(Minus 15 bytes thanks to @manassehkatz!)

# [Triangularity], 49 bytes

    .... ....
    ..."!"...
    .."rld"..
    ."o, Wo".
    "Hell"+++

[Try it online!][TIO-k758litl]

[Triangularity]: https://github.com/Mr-Xcoder/Triangularity
[TIO-k758litl]: https://tio.run/##KynKTMxLL81JLMosqfz/Xw8IFEAEFxArKSpBWEpFOSlKIJZSvo5CeL6SHpeSR2pOjpK2tvb//wA "Triangularity – Try It Online"

# C#, 45 bytes

```
()=>System.Console.WriteLine("Hello World!");
```

This is an anonymous function that prints `Hello World!`. To run it, you would assign it to a variable and then call the variable like a function:

```
var func = () => System.Console.WriteLine("Hello World!");
func();
```

If that doesn't count, a full program would be 70 bytes:

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

# C#, 27 bytes

```
WriteLine("Hello World!");
```

[Try it online!][TIO-kvl15i90]

[C# (Visual C# Interactive Compiler)]: http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc
[TIO-kvl15i90]: https://tio.run/##Sy7WTS7O/P8/vCizJNUnMy9VQ8kjNScnX0chPL8oJ0VRSdP6/38A "C# (Visual C# Interactive Compiler) – Try It Online"

# Haskell, 15 bytes (function)

    "Hello, World!"
    
In Haskell functions are curried so the string `"Hello, World!"` is no different from a function that takes no arguments and outputs the string.

For a complete program:

# Haskell, 26 bytes (program)

    main=putStr"Hello, World!"
    
This uses `putStr :: String -> IO ()` to turn the string `"Hello, World"` into an `IO` action that results in `()` (Haskell's terminal object, other languages have `void`).  This `IO` action will result in the string `Hello, World!` being output to the console.  We then assign this result to `main`, which is a special function that Haskell calls when the program is run.

# [APL (Dyalog Unicode)], 15 bytes
Full program.
```apl
'Hello, World!'
```
[Try it online!][TIO-k5yzbyz0]

[APL (Dyalog Unicode)]: https://www.dyalog.com/
[TIO-k5yzbyz0]: https://tio.run/##SyzI0U2pTMzJT///qKO94L@6R2pOTr6OQnh@UU6KojpI8D8A "APL (Dyalog Unicode) – Try It Online"

# [Japt], 11 bytes

    `HÁM, WŽld!

[Try it online!][TIO-k601tfhj]

[Japt]: https://github.com/ETHproductions/japt
[TIO-k601tfhj]: https://tio.run/##y0osKPn/P8HjcKOvjkL4ob6cFMX//wE "Japt – Try It Online"

Japt has compressed strings delimited by backticks `` ` ``, and supports auto-closing of string literals and parentheses.

The character on the right of W has charcode 142 (0x8E). Japt's default encoding is [ISO-8859-1](https://en.wikipedia.org/wiki/ISO/IEC_8859-1).

# [Agony], 236 bytes

    >++++++++{++++}.>+++++{++++++}.>++++++++++++{++++++}.>++++++++++++{++++++}.>+++++++++++++++{++++++}.>++++++++++++{++}.>{++}.>+++++++{+++++}.>+++++++++++++++{++++++}.>++++++++++++++++++{++++++}.>++++++++++++{++++++}.>++++{++++++}.>+{++}.

[Try it online!][TIO-k780a6go]

[Agony]: https://github.com/royvanrijn/JAgony
[TIO-k780a6go]: https://tio.run/##S0zPz6v8/99OGwqqQUStnh2Cg@AiKyFSFJ9yoEg1sng1SQYQ7xYkHti@//8B "Agony – Try It Online"

(Disclaimer: I don't understand any of this code)

# [SQLite](https://sqlite.org/index.html), 22 bytes

```sql
select'Hello, World!';
```
[Try it online!](https://tio.run/##Ky7MySxJ/f@/ODUnNblE3SM1JydfRyE8vygnRVHd@v9/AA "SQLite – Try It Online")

# [Kotlin], 17 bytes

    {"Hello, World!"}

[Try it online!][TIO-k8469x3n]

[Kotlin]: https://kotlinlang.org
[TIO-k8469x3n]: https://tio.run/##y84vycnM@1@WmKOQYaWgoamga6cQXFKUmZeuYPu/WskjNScnX0chPL8oJ0VRqfZ/WmmeQm5iZh5Qoa1CAVBZiUaGhqbmfwA "Kotlin – Try It Online"

# [Ahead], 17 bytes

    "!dlroW ,olleH"W@

[Try it online!][TIO-k7mzjxka]

[Ahead]: https://github.com/ajc2/ahead
[TIO-k7mzjxka]: https://tio.run/##S8xITUz5/19JMSWnKD9cQSc/JyfVQync4f9/AA "Ahead – Try It Online"

# [Erlang (escript)], 21 bytes

    f()->"Hello, World!".

[Try it online!][TIO-k7ifqgtz]

[Erlang (escript)]: http://erlang.org/doc/man/escript.html
[TIO-k7ifqgtz]: https://tio.run/##Sy3KScxL100tTi7KLCj5z/U/TUNT107JIzUnJ19HITy/KCdFUUnvf25iZp5GdCxQKjPfKq28KLMkVQOoUlPvPwA "Erlang (escript) – Try It Online"

# [Nim], 19 bytes

    echo"Hello, World!"

[Try it online!][TIO-khp2evd8]

[Nim]: http://nim-lang.org/
[TIO-khp2evd8]: https://tio.run/##y8vM/f8/NTkjX8kjNScnX0chPL8oJ0VR6f9/AA "Nim – Try It Online"

# [Jelly], 8 bytes

    “3ḅaė;œ»

[Try it online!][TIO-khp2au88]

[Jelly]: https://github.com/DennisMitchell/jelly
[TIO-khp2au88]: https://tio.run/##y0rNyan8//9RwxzjhztaE49Mtz46@dDu//8B "Jelly – Try It Online"

## Explanation

    “3ḅaė;œ»   Main niladic link
    “3ḅaė;œ»   Dictionary-compressed string "Hello, World!"

# Vyxal, 2 bytes

```
kH
```

[Python 3](https://www.python.org), 22 bytes
```python
print("Hello, World!")
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EQ8kjNScnX0chPL8oJ0VRSfP/fwA "Python 3 – Try It Online")

# [V (vlang.io)], 22 bytes
```
print('Hello, World!')
```
[Try it online!][TIO-kvl1cvqb]

[V (vlang.io)]: https://vlang.io
[TIO-kvl1cvqb]: https://tio.run/##K8tJzEv//7@gKDOvREPdIzUnJ19HITy/KCdFUV3z/38A "V (vlang.io) – Try It Online"

# [JavaScript (Node.js)], 18 bytes

```javascript
_=>"Hello, World!"
 ```
[Try it online!][TIO-ku3oimu0]

[JavaScript (Node.js)]: https://nodejs.org
[TIO-ku3oimu0]: https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1k7JIzUnJ19HITy/KCdFUel/cn5ecX5Oql5OfrpGmoam5n8A "JavaScript (Node.js) – Try It Online"

Arrow function taking no argument (hence `_`) and returning "Hello, World!". Posting since there doesn't seem to be JS answer

Alternately : 

# [JavaScript (Node.js)], 20 bytes


```javascript
alert`Hello, World!`
```