Hello, World! with semi-common characters
Perl 5, 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)). 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! - uses /\w/ in place of ?\w? as the version of Perl on TIO is too new.
Perl 5, 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!
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 0s. 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 it, I'm making this a wiki post.
05AB1E, 137 106 95 bytes
X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B
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, 211 186 166 bytes
0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B
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.