[Question]
  [
In any programming language that existed before this question was asked, write a program (not a function) that outputs the characters `Hello world!` followed by a newline. Your program:
* should not use any character more than once (including whitespace)
* should only use ASCII characters
* should not use any built-in libraries
* should not get input (user, file, filename, system variable, internet, anything)
* should not output anything else
Winner is whoever has the most votes after 14 days and abides to the six rules.
The sixth rule is that you cannot use H9+, HQ9+, HQ9+B, HQ9++, HQ9+2D, Hello, Hello+, Hello++, Hexish, CHIQRSX9+, or Fugue. Also, all answers which require implementations that are newer than this challenge must be marked as non-competing.
---
**Disclaimer:** This question was posted with the assumption that [Hello world! with limited repetition](https://codegolf.stackexchange.com/questions/18721/hello-world-with-limited-repetition) did not cause any damage to your computer or your brain in the process of coming up with the answers.
  
[Answer]
# Raku (~~29~~ 28 characters)
This was somewhat annoying, but I finally managed to make a program for this task. Thanks go to the [great #perl6 community](https://web.archive.org/web/20140128181911/http://irclog.perlgeek.de/perl6/2014-01-20#i_8146203), for helping me with this task. It took me two hours, hope you enjoy. The output is completely up to specification, including a newline.
```
say
Q[@A`DO world!]~|<HeLhg>
```
There are four tokens of interest.
* `say`
This outputs the argument with new line at end. The new line after the command itself is needed as a space replacement.
* `Q[@A`DO world!]`
This is the first string. `Q[]` is for raw strings (like `r""` in Python). It can take any delimiter (or pair of them), in this case `[]`. In this case, I use this for quotes, I don't need raw string behavior.
* `~|`
This is stringwise (`~`) bitwise or (`|`) operator.
* `<HeLhg>`
`<>` is list literal, which takes space separated list of elements. In this case, it has one element, and used as a scalar, it gives a string.
[Answer]
# Perl 5.10+: 24 chars
```
say+He,YZX^q(567 world!)
```
OK, I think this is as short as it gets in Perl.
Run with `perl -M5.010` (or just `perl -E`) to enable the Perl 5.10+ `say` feature.
[Answer]
# [Perl 5](https://www.perl.org/) with `-M5.010`, 29 bytes
```
say+He.v108
x2,q(O world!)^$"
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVLbI1WvzNDAgqvCSKdQw1@hPL8oJ0VRM05F6f//f/kFJZn5ecX/dX1N9QwMDQA "Perl 5 – Try It Online")
I've gained a lot of knowledge since I first attempted this. Still not as short as the other answers, but the best I can come up with!
[Answer]
# Vim 7.3, 18 keystrokes
```
:h-cu
9j3wy$<C-^>P<End>r!o
```
Copies the string `Hello world` from [this helpfile](http://vimdoc.sourceforge.net/htmldoc/if_tcl.html), which unfortunately has been removed in never versions of Vim.
[Answer]
# Golfscript 42 33
I might as well golf this, considering that I had to fit some of the code and all of the data in the same block with no way of delimiting the two I think this is a pretty short result. Unlike my first submission the block code is now a fully integrated part of the data, thus `{1` do not only begin the block and put a `1` on the stack, it is also the data that defines the `H`, and so forth. The array creation now includes the empty input string, which means that I don't have to crop the beginning as there is only one character between the empty string and the `H`, that character is cut away when I take every second character, and the empty string eventually is output as nothing.
```
{1wZ$Qei^Ak 3h-)ulmsogr7}.`*]2%n+
```
Online demo: <http://golfscript.apphb.com/?c=ezF3WiRRZWleQWsgM2gtKXVsbXNvZ3I3fS5gKl0yJW4r>
```
[{1$^(r iFNGDJUHv98oIMgtplbh4m}.`\*]6>2%n+
```
Defines a code block. Makes a copy of the code block and converts it to string. Uses the code block to iterate over the string. For each iteration the code will make a copy of the previous char value, xor it with the current char value, and subtract 1. The resulting string then has the first 6 characters removed, and every second character removed. Finally a line feed is appended.
"r iFNGDJUHv98oIMgtplbh4m" is just two undeclared variables, they do nothing, but they are carefully constructed to produce the desired result.
Online demo: <http://golfscript.apphb.com/?c=W3sxJF4ociBpRk5HREpVSHY5OG9JTWd0cGxiaDRtfS5gXCpdNj4yJW4r>
[Answer]
# [Befunge-98](https://github.com/catseye/FBBI), ~~34~~ 31 bytes
```
f"v!dlrow
+c<>a,kb@#*98e':g05-3
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/P02pTDElpyi/nEs72cYuUSc7yUFZy9IiVd0q3cBU1/j/fwA)
Uses quite a few different methods to avoid duplicated characters.
First, we use wrapping string literal to avoid using two `"`s. This adds " world!" to the stack.
Going left on the second line, we add 9 to the extra `f` to make the `o` of the "Hello". We `g`et the character from cell 5,0 (`l`) and then duplicate it. The `'` is used to fetch the letter `e`. Multiply 9 by 8 to get 72, the ASCII value of `H`. We then print it everything using `ck,`, and flip the direction with the `>` to reuse the `,` to print the newline (`a`).
[Answer]
# [Elixir](https://elixir-lang.org/), 37 bytes
```
IO.puts~c(He#{[?n-2,108]}\x6f world!)
```
[Try it online!](https://tio.run/##S83JrMgs@v/f01@voLSkuC5ZwyNVuTraPk/XSMfQwCK2NqbCLE2hPL8oJ0VR8/9/AA "Elixir – Try It Online")
I can't guarantee that this would have worked back in 2014 when this challenge was posted, and Elixir was still pre-1.0 (and thus, whether it is formally "competing", but looking at their release notes, I think it should be OK).
Anyway, I'm happy that I finally found a valid solution to this task using a conventional general purpose language other than Perl!
### Walkthrough
```
IO.puts     #Print with trailing newline
~c(...)     #Sigil: charlist with interpolation
He          #Start of literal string...
#{...}      #Interpolated block
[?n-2,108]  #A list of codepoints for 2 'l's
\x6f        #Hex code for 'o'
world!      #...and done!
```
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), 17 bytes
```
Hel:o Wn1+rp4-d\!
```
[Try it online!](https://tio.run/##y05N///fIzXHKl8hPM9Qu6jARDclRvH/fwA "Keg – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 6 bytes
```
kh\!+,
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJraFxcISssIiwiIiwiIl0=)
Basically the normal way of printing "Hello World!" in Vyxal.
[Answer]
# [Vim](https://www.vim.org), 21 keystrokes
```
2iHelo WORLD!Escgu8h10X
```
[Try it online!](https://tio.run/##K/v/3yjTIzUnXyHcP8jHRVE6vdQiw9Ag4v9/AA "V (vim) – Try It Online")
Vim adds a newline at the end of the file so there's no need to add it explicitly.
### To run it locally:
1. Save the code to a file *(here hello\_world.vim)* replacing `Esc` with `` (`\x1b`).
2. run `vim -u NONE -s hello_world.vim hello_world.txt`.
3. [exit Vim](https://stackoverflow.com/questions/11828270/how-do-i-exit-vim).
[Answer]
# [Uiua](https://uiua.org), 30 bytes
```
&p+mod107\*-,:@$ H`eFMbv/5la
```
[Try it online!](https://www.uiua.org/pad?src=JnAr4pe_MTA3XMOXLSziiLZAFSQgSGBlFkZNYnYvNWxhCg==) (Note that the formatter automatically converts some ASCII tokens to Unicode equivalents, but you can verify the solution by copy-pasting the code above and running it manually.)
[Verify the restrictions!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYKlpSVpuhY3U4tti9TVCrRz81MMDcxjtHR1rBxEVRQ8ElLF3HyTyvRNcxLVuQqKMvNKNHJS8zSKNRVsbRXArNQSIE9TEyqZmJOjkV-UopGsqWBjq2BoZK6Qll-kkKyQmacAVAWxDGonzG4A)
Contains two ASCII control characters; I'm assuming this is valid based on the existing Vim answers.
This code solves the duplicate character problem by finding an integer `p` and a list of integers `L` such that the cumulative product of `L` modulo `p` gives the desired string. Also, a character literal is used twice because both "convert string to a list of charcodes" and "convert a list of charcodes to string" require a character literal, and it is chosen so that the resulting `p` and `L` meet the no-duplicates requirement.
`$ <string>` is a multiline string literal that continues through lines that start with `$`  and ends at a newline after that.
```
&p+mod107\*-,:@$ H`eFMbv/5la
                $ H`eFMbv/5la    push a string literal, S
              @                  push a character literal, c
            ,:   swap and over; c S c
           -     S-c; convert S to charcodes and subtract c's charcode
         \*      cumulative product
   mod107        % 107
  +              add c; add c's charcode and convert to string
&p               print with newline
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 8 bytes
```
`dx/&\p4
```
[Try it online!](https://staxlang.xyz/#c=%60dx%2F%26%5Cp4&i=&a=1)
Just a compressed string literal. Luckily Stax lets me go without the closing backtick.
[Answer]
An answer from <https://codegolf.stackexchange.com/a/55425/118820>:
> 
> **Stuck, 0 bytes**
> 
> 
> Well, can't get shorter than that... An empty program
> will output `Hello, World!` in [Stuck](http://esolangs.org/wiki/Stuck).
> 
> 
> 
Even Stuck comes with 3 plugins, but we don't need they.
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), 25 bytes
```
"v!dlrow 
H>{7-5k:`e01ga}
```
[Try it online!](https://tio.run/##S8/PScsszvj/X6lMMSWnKL9cgcvDrtpc1zTbKiHVwDA9sfb/fwA "Gol><> – Try It Online")
```
"v!dlrow      push "v!dlrow " where v is the bottom of the stack
 >{           bring v to the top
 7-           subtract 7 from v to get o
 5k:          fetch 5th number down the stack which is l, and duplicate it
 `e           push e
 01g          fetch H from the code area
 a}           put 10 (newline) at the bottom of the stack
H             print the whole stack as chars from top to bottom and halt
```
# [Gol><>](https://github.com/Sp3000/Golfish), 30 bytes
```
"\>mX.R
Mkp
r<;|%q`*o+a:Fd~
```
[Try it online!](https://tio.run/##S8/PScsszvj/XynGLjeCUU8wiFnWN7uAq8jGuka1MEErXzvRyi2l7v9/AA "Gol><> – Try It Online")
Same strategy as [my own Uiua answer](https://codegolf.stackexchange.com/a/266319/78410) applied to Gol><>.
Uses printing offset of 10 (`a+o`) so that the newline can be printed without an explicit stack item.
```
"\...    push a backslash and the string, and then reflect down
r<   ~   reverse stack and discard the backslash
|...Fd   repeat the loop 13 times:
o+a:       print the current number plus 10 as char
%q`*       multiply modulo 113
;        halt
```
]