[Question]
  [
As some of you may know, to get a language onto Dennis's wonderful [Try It Online!](https://tio.run/#), a Hello, World! program is required. Recently, Dennis pushed up a way to load these programs from the website. Here is a JSON [pastebin](https://pastebin.com/jVifgcZ6) of the characters used in those programs, by frequency, as of July 27, 2017.
Some of those characters need some love, so your challenge is to output Hello, World! (preferably in a language involved in this process), using only the characters specified below. These characters are all of the characters used between `10` and `99` (inclusive) times, along with the two most common characters, `0` and , because I'm feeling nice.
```
0 $&*?ABCDEFGIJKLNPQRSTUXYZ\`gjkqwxyz{}÷≤≥=║_
```
Your usage of the character should be based on its appearance in a normal program, not based on its code point or byte value.
You must use at least one character from that set, so 0-length programs are invalid.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.
[JSFiddle to check if your answer is valid](http://jsfiddle.net/t4ujwm1s/2/embedded/result/)
  
[Answer]
# [Perl 5](https://www.perl.org/), 76 bytes
```
}{${$_=$`x?B?}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}=$_=\*G
```
This uses a feature that has been deprecated, but works locally in my terminal (which is version 5.18.2 as noted). In older versions of Perl `?\w?` is a synonym for `/\w/` which gives me access to regexp matching and I have enough chars for `$&` (last match) and `$`` (text preceding last match). I need these to be able to get the `O`. I generate this be creating a `glob` reference (`$_=\*G` which, cast to a scalar, is [something like `GLOB(0x7ffb728028d0)`](https://tio.run/##K0gtyjH9/7@gKDOvRCFGy/3/fwA "Perl 5 – Try It Online")). Once that's in `$_`, `?B?` will match the `B` and `$`` will contain `GLO`, I can then match against `\w$` which would store `O` in `$&` which is inserted into the strings that I'm running stringwise-AND to create the rest of the text, the body of the string is lowercased using `\L`.
[Try it online!](https://tio.run/##K0gtyjH9/19ZobZapVol3lYlocLeyb622j6mXAVIAUUKC6t90mN8fHxU1GwVylXUgnxcbGvVCgttK2shoj4K8WBRR9taW6D6GC13LoRh@k76tdX6QMP0yTXs//9/@QUlmfl5xf91CwA "Perl 5 – Try It Online") - uses `/\w/` in place of `?\w?` as the version of Perl on TIO is too new.
---
# [Perl 5](https://www.perl.org/), 65 bytes
This is a bit more cheaty as it relies on the filename on TIO (which is `.code.tio`), so I don't really think this is competing, but I was happy with the result!
```
}{${$_=$0}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}
```
[Try it online!](https://tio.run/##K0gtyjH9/7@2WqVaJd5WxaC2Wj@mXEW/FsQrLKz2SY/x8fFRUbNVKFdRC/Jxsa1VKyy0rayFiPooxINFHW1r////l19QkpmfV/xftwAA "Perl 5 – Try It Online")
[Answer]
# [Unary](https://esolangs.org/wiki/Unary), 7\*10182 bytes
Unary is Brainfuck converted to binary converted to unary using `0` as the counter. Essentially, it condenses a Brainfuck program into a number and the output is that number of `0`s. They are usually very large programs.
I won't paste the program here because I don't know how much text SE allows but I bet it's less than this. Instead, I'll paste the precise number of zeroes in this answer:
```
708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556
```
As this is a fairly cheap answer, guaranteed to not be the shortest, and I simply [copied](http://progopedia.com/example/hello-world/191/) it, I'm making this a wiki post.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~137~~ ~~106~~ 95 bytes
```
X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/wsAAiFwiYAQQR4BFgCwwG4wioEQEGBhAaIgKkEoDIOkCEvVyBjLTQWwgpaWl5fT/PwA "05AB1E – Try It Online")
-31 thanks to @Adnan for pointing out I could use base 108.
-?? thanks to @Riley for pointing out some things wrong.
---
***Old version (different method):***
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~211~~ ~~186~~ 166 bytes
```
0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fIN0AhKAgPTQCyoiAMNIhGEy5QAQUDGA60iNQKLAMkmnpCBoh5mKArAckkw6z2SvCAB2A7dXScvr/HwA "05AB1E – Try It Online")
---
Haha! AND HERE I THOUGHT ESOLANGS STOOD NO PLAUSIBLE CHANCE!
---
**First we get 255 stored in X:**
```
00g               # Push 2 (length of 00).
   00000g         # Push 5 (length of 00000).
         00000g   # Push 5.
               JU # Join to 255 and store in X.
```
**Then, using the same length trick we push: `1296995323340359595058728869715`**
```
0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ
```
Where we just use `0<space>` instead of the length trick for the zeros.
**Then, finally, we push the 255 we stored and convert from 255 to base 10**:
```
X  # Push stored 255.
 B # Convert to base 255.
```
---
Still golfing using the other allowed chars, and duplication, it will be a minute.
[Answer]
# [Beatnik](https://esolangs.org/wiki/Beatnik), 148 bytes
```
K QQQQQQQG ZD XA K QQJA KD ZD XA K KG KD ZD ZD ZD XA XA K B KD ZD XA K QQQQF ZD ZD XA K QQQD XA K A Z KD XA ZD XA K B KD XA ZD XA K J Z XA K QQQB XA
```
[Try it online!](https://tio.run/##S0pNLMnLzP7/31shEALcFaJcFCIcFUACXkDKBc73dofyomBiYGEnZDUgE9wQCsACUJajQhRIJZANk3NC43sBVcA0OQFZ//8DAA "Beatnik – Try It Online")
## Explanation
Beatnik bases the instruction executed based on the scrabble score of the word. Here's a shortened explanation:
```
Code         Scrabble Score   Explanation
K            5                push the scrabble score of the next word
QQQQQQQG     72               72 ['H']
ZD           12               pop a value; push it back twice
XA           9                pop a value; print its ASCII character
KD           7                pop two values; push their sum
Z            10               pop two values; push their difference
```
[Answer]
# Moorhens (v2.0), ~~3423~~ ~~983~~ ~~923~~ ~~866~~ ~~749~~ 716 bytes
I think this can be golfed a bit, Moorhens is not an easy language to work with.
```
xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU KA AA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU KA KA xU xU xU AA AA AA AA AA KA xU AA KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU KA XI XI XI XI XI XI KA XI XI XI XI XI XI XI XI AA AA AA AA AA AA AA AA AA AA AA AA
```
## Explanation
Moorhens is a language based of of dictionary words. Each word corresponds to an operation based on its hash. The five operations used here are `xU`, `ER`, `XI`, `KA`, and `AA`
* `xU` increments the TOS
* `ER` puts a new zero on the stack.
* `XI` decrements the TOS
* `KA` duplicates the TOS
* `AA` rolls the TOS to the bottom
We push each letter with sucessive applications of these operations.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), ~~89~~ ~~75~~ 68 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
z{}xxxx≥x≥x≥xXUqXxq≤qq≤q *R_IIRq  q *R_I0II*IRqxXq≤qxqxq CR_0II÷Rq0*
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=eiU3QiU3RHh4eHgldTIyNjV4JXUyMjY1eCV1MjI2NXhYVXFYeHEldTIyNjRxcSV1MjI2NHElMjAqUl9JSVJxJTIwJTIwcSUyMCpSX0kwSUkqSVJxeFhxJXUyMjY0cXhxeHElMjBDUl8wSUklRjdScTAq,v=0.12)  
Note: whenever `q` or output is referred to here, it doesn't pop as popping output (any of `oOpP`) are unavailable or output a prepending newline.
Explanation (outdated, what's changed is that the "H" is printed using the alphabets letters):
```
 $             push "$"
  R_           convert to an array of ordinals, then push all the contents to the stack
    0II        push 0+1+1 = 2
       *       multiply by that
        R      convert to character
         q     output
          z    push the lowercase alphabet
           {}  iterate over it, pushing each char, and do nothing. Stack: ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
stack manipulation:
 xxxx ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r"]
 ≥    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q"]
 x    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o"]
 ≥    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n"]
 x    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l"]
 ≥    ["l","o","r","H","a","b","c","d","e","f","g","h","i","j","k"]
 xxx  ["l","o","r","H","a","b","c","d","e"]
 q    output the "e"
 ≤    ["o","r","H","a","b","c","d","e","l"]
 qq   output the "l" twice
 ≤    ["r","H","a","b","c","d","e","l","o"]
 q    output the "o"
*                       push "*",
 R_                     convert to an array of ordinals, then push all to stack
   II                   increase by 2
     R                  convert back to character
      q                 output
         q              push a space, then output
           *            push "*"
            R_          convert to an array of ordinals, then push all to stack
              I         increase that
               0II      push 0+1+1 = 2
                  *     multiply
                   I    increase
                    Rq  output as character
stack manipulation: (starting stack: ["r","H","a","b","c","d","e","l","o",","," ","W"])
 x  ["r","H","a","b","c","d","e","l","o",","]
 X  ["r","H","a","b","c","d","e","l","o"]
 q  output the "o"
 ≤  ["H","a","b","c","d","e","l","o","r"]
 q  output the "r"
 x  ["H","a","b","c","d","e","l"]
 q  output the "l"
 x  ["H","a","b","c","d"]
 q  output the "d"
C            push "C"
 R_          convert to ordinal as before
   0II÷      floor divide by 2
       Rq    output as character
         0*  multiply by 0 so nothing extra would be outputted
```
Fun fact: all of the characters from the allowed characters are in SOGLs codepage :D
[Answer]
# [Glypho](https://web.archive.org/web/20060621185740/http://www4.ncsu.edu/~bcthomp2/glypho.txt), 480 bytes
```
AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB
```
[Try it online!](https://tio.run/##hVBbDoAwCDtb2WH0w0R/PT0KstgxiWHJCrS8lu081l0VkAYxE/jvfmBh3M38IsZaw1OtpGfOyB05Tsv9OY@OI94wzfU9C@9ONege766pR@Tyzr@zNhS1xluUdynmdsnj3M80FhPVCw "Glypho – Try It Online")
[Answer]
# Double JavaScript, 318 bytes
I'm not sure if that's allowed, I couldn't do it using the JavaScript interpreter once. It's similar to use `eval()` but instead I'm using the interpreter twice: (Try it in the console to get the result printed back)
```
`\`\\x${0xA*0xA&0xC}${0xA&0xC}\\x${0xA*0xF&0xF}${0xB*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}F\\x${0xE*0xF&0xF}C\\x${0xE*0xF&0xF}${0}\\x${0xB*0xF&0xF}${0xB*0xB*0xF&0xF}\\x${0xA*0xF&0xF}F\\x${0xB*0xB*0xF&0xF}${0xE*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}${0xA*0xA&0xC}\\x${0xE*0xF&0xF}${0**0}\``
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/V9h@z8hJiEmpkKl2qDCUQuI1QwqnGvBPDALScoNKOAGlnKC8zCknYkQcYOKuGKocUW2Bma4E4bdeOx3Q9KEqtGVFEejBgc212lpAR2YkPA/OT@vOD8nVS8nP12jQvM/AA "JavaScript (Node.js) – Try It Online")
Evaluates to:
```
`\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21`
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/V9h@z8hpsLEIqbCzBSInaHYLabCCEgbGcRUmJpD@OZGUDkToLhhwv/k/Lzi/JxUvZz8dI0Kzf8A "JavaScript (Node.js) – Try It Online")
Which evaluates to `Hello, World!`
[Answer]
# [Headsecks](https://esolangs.org/wiki/Headsecks), 78 bytes
```
yyzyzzxNxNzx{yyy{y{y{yzzz_{_zzyy\zxxxxxx\zzy\\zz\zx\{{\{{\zzz\xxx\{{\{{y\zzzx\
```
[Answer]
# [Smallf\*\*k](https://github.com/alexander-liao/smallf-k), 266 bytes:
```
zJ$NJ`ZZx*gQYQQ{zqyKKUkUR?AS`zB`JB&UCKCIxQ_G0*000FzzJ&?YwkC\qqgZ`xYQyC}DgY_&_S}KPZ\&?SGAE&{Gw_w} GAgA{qT{gC&`qI?xwCNQwgR}?{*QEwQUj&BT&jR__IJJIqUqAPF0yICXESL?AYR QIAFU& yYwE&$\Njj B0T*F j$?kCzQk*}U}UgI$}Ew_yDL`qYI*E_G}SCjXDFNJKGNIGyIwA\BzLP`*zCILGCNqyYZyq? GwN{q{gKSj
```
Actually, the characters are kinda irrelevant. It's just a matter of whether or not each character has an even codepoint or an odd codepoint. Thus, I've made an effort to use every character available (except the multibyte characters) (though since it was randomised, I didn't make an effort to guarantee that).
[Answer]
# [Pyke](https://github.com/muddyfish/PYKE), ~~133~~ 144 bytes
```
? BXKKKKRKRKRK\CkJ00q}}}XEjTX}G_E\E\L\LkJjRT}}XRGREkJjR 00q}R? B_RE\ \wkJjRT}}XRGRE\R\L\DkJjRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJjRT}}RG_RE00q}}RAA
```
[Try it online!](https://tio.run/##TU07CoAwDL1Kj@ANpGootJ0eDkUCTi7topM49Ow1UQcTQsL7Zb/K1lpvhhSk8DSPxXfdUWtNlOdU3UpMHDkWnzELCgfS26gKYl5BbPj88wxxTIosGvWpZHmZAFqy4vYNEhOc0M9XWNvaDQ "Pyke – Try It Online")
A horrible mess of code that can almost certainly be shortened... Constructs it one character at a time. 
```
? BXKKKKRKRKRK\CkJ - ".C" - A string that when evaled, gets the character at the point
00q}}}XEj - Construct 64 by doing `((0==0)*2*2*2)**2` and then eval, getting the "@" character and store it in `j`
TX}G_E - Get "h" using `@` by looking it up in the alphabet
\E\L\LkJ - "hELL"
jRT}}XRGREkJ - "hELLo"
jR 00q}R? B_RE  - ","
\ \wkJ - "hELLo, w"
jRT}}XRGRE\R\L\DkJ - "hELLo, woRLD"
jRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJ - "hELLo, woRLD!"
jRT}}RG_RE00q}}RAA - "Hello, World!"
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 33 bytes
```
`gDKKN`\*kP*JkP*` w`J`NQKCZ`kP*JN
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJgZ0RLS05gXFwqa1AqSmtQKmAgd2BKYE5RS0NaYGtQKkpOIiwiIiwiIl0=)
As I've golfed this, it's become a lot more straightforward. For reference, the original looked something like [this](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJrQXl5eWdgRUxMYE4wa0x5X0p5X3lfeV9HRF9EPURfSkRfVCtDYCB3YE5KSiRgUkxEYE5KSkpKRD1EX0pUQ0oiLCIiLCIiXQ==).
For convenience, the string is constructed swapcase'd, then fixed at the end.
This program makes heavy use of `kP*` - `*` in this context is ring translate, and `kP` printable ASCII, which is [arranged a bit weirdly](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJrUCIsIiIsIiJd).
```
       \*kP*                      # The character `+`, made by ring translating `*`
`gDKKN`     J                     # Append that to `gDKKN`
             kP*                  # Ring translate again, producing `hELLO,`
                ` w`J             # Append ` w`
                     `NQKCZ`kP*   # The string `NQKCD` ring translated to `ORLD!`
                                  # Don't ask why Z wraps to `!`
                               JN # Append that and swap the case.
```
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), ~~164~~ 162 bytes
```
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzS zzS?zzzzzzzzzzzzS$zzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzzzzzzzzzzzzzzzSwzzzzzzzzzzzzzzzPzzzzzzzzSLzPzPzzzzPL$PL PLwPzPzzzzPLLPAI*PL?P
```
[Try it online!](https://tio.run/##S0n@/7@KEAhWAGJ7FBEVvBoCMEwox6Ui2AfIBvMCfFQCfBQCfMrhfJ8AR0@tAB/7gP//AQ "dc – Try It Online")
There's likely a better/more interesting approach. I tried using the ASCII+256 trick that `dc` has, but that outputs additional characters as well (even if they're non-printing), and once I got to 'o', the wonderfully prime 111, I ran into trouble even getting a value of 111+(multiple of 256) that factored cleanly. So here's a fairly straightforward (albeit golfed where possible) solution:
In `dc`, `z` is a command that pushes the stack depth onto the stack. That means we can use it as an increment. This is how I create most of my ASCII values for this challenge (printed with `P`), which I push onto named stacks with `S` and pop back onto the main stack with `L`. 
`dc` lets you use the hex values A-F even when the input radix is decimal (default). ~~Luckily, our first letter, 72, is a multiple of 12, so I save a byte or two here by multiplying 6\*12 and printing immediately (`zzzzzzzC*P`).~~ My 164-byte version used multiplication early on to get 72 ('H'), which was mildly clever but a holdover from an earlier attempt, and a waste of bytes. Now, I start by incrementing and saving the space, the exclamation point, and the comma, which are out of order, and therefore can't be printed yet. Next, I come to the 'H', which I print immediately, before I get to 'W', which I must save for later.
I simply print when I hit the 'e', then I increment up to 'l'. I print two of those and save one. When I make it to 'o', I first thought I'd have to save one of those for later, but everything is *kind of* in order at this point. I print an 'o', retrieve my comma, space, and 'W' from earlier, and now I'm right back to 'o'. I print this, and increment a few up to the highest necessary value, 'r' (114), which I print before loading and printing the 'l' I tucked away earlier.
Almost done! 'd' is ASCII value 100, which is easily made by multiplying 10\*10 (fewer bytes than having stored it earlier and loading it now). Hex value `A` is 10, as is our input radix which we can retrieve with the command `I`. Multiply those, print, and then load and print our exclamation point from earlier. Hello, World!
[Answer]
# Deadfish~
```
w
```
Honestly, the other answers are way more impressive.
]