[Question]
  [
Your job is quite simple, write a program that prints `Hello, world!`, that when twisted creates a program that prints `Twister!`.
## How strings are twisted
The twisting algorithm is very simple. Each column is shifted down by its index (col 0 moves down 0, col 1 moves 1, ...). The column shift wraps to the top. It kinda looks like this:
```
a
ba
cba
----
 cba
  cb
   c
```
With everything under the line wrapping to the top. Real example:
```
Original:
\\\\\\\\\\\\
............
............
............
Twisted:
\...\...\...
.\...\...\..
..\...\...\.
...\...\...\
```
(Further examples and a twisters in your favorite language are [here](https://codegolf.stackexchange.com/questions/70696/golf-a-string-twister))
## Scoring
Your program must be a padded rectangle. This is code-golf so lowest byte count wins!
## Rules
* Your first program must print `Hello, world!`. Only one trailing newline is allowed.
* Your first and second programs must be in the same language.
* Your second program must print `Twister!`. Only one trailing newline is allowed.
* Your program must have at least 2 rows and 2 columns.
  
[Answer]
# Python 2, 59 bytes
```
print "  Hello, world!"[ 2::]
#rint "T w i s t e r !"[ ::2]
```
Twisted:
```
print "T weils,twerrd!"[ ::2]
#rint "  H l o   o l !"[ 2::]
```
Basically, puts the `Twister!` data in the odd indices of the string and then changes from removing the first two (padding) characters to removing every other character instead.
[Answer]
## [Fission](https://github.com/C0deH4cker/Fission), ~~215~~ ~~162~~ ~~56~~ ~~53~~ 50 bytes
Here is a start:
```
D1
\\
""
TH
we
il
sl
to
e,
r 
!w
"o
1r
;l
1d
;!
 "
```
[Try it online!](http://fission.tryitonline.net/#code=RDEKXFwKIiIKVEgKd2UKaWwKc2wKdG8KZSwKciAKIXcKIm8KMXIKO2wKMWQKOyEKICI&input=)
When twisted:
```
D"
\1
"\
T"
wH
ie
sl
tl
eo
r,
! 
"w
1o
;r
1l
;d
 !
```
[Try it online!](http://fission.tryitonline.net/#code=RCIKXDEKIlwKVCIKd0gKaWUKc2wKdGwKZW8KciwKISAKIncKMW8KO3IKMWwKO2QKICE&input=)
### Explanation
The `Hello, world!` code is fairly simple:
* `D` spawns a single atom, going downwards.
* The two `\` (mirrors) deflect it onto the second column.
* `"Hello, world!"` prints the required string.
* `1` is a portal. It teleports the atom to the next `1` in reading order, retaining its direction (that's the one next to the `r`).
* The atom still moves down, into the `;` which destroys the atom and terminates the program.
The control flow for the `Twister!` code is a bit more... twisted...
* Again, `D` spawns the atom.
* `\` deflects it to the right, into the `1`.
* Now the portal sends the atom to the next `1`. The atom hits the `o` which just changes its mass, but we can ignore that. The code wraps around so the atom hits the same `1` again, skipping down two rows. Again, we can ignore the `l`, the atom wraps around and hits the `1` again. Now there is no further `1` in the code so the atom skips all the way back to the `1` at the top.
* After wrapping around the edges once more, the atom is deflected again by `\`, now going down again.
* `"Twister!"` prints the required code.
* `1` teleports the atom once more, past the first `;`, but there is another `;` waiting for it to terminate the program.
[Answer]
## [Fission](https://github.com/C0deH4cker/Fission), 35 bytes
Fission approach #3 (#4 counting the one I edited out of my first post).
```
R"Hello, " \"tri"
T;L"!dlrow"/"es!w
```
[Try it online!](http://fission.tryitonline.net/#code=UiJIZWxsbywgIiBcInRyaSIKVDtMIiFkbHJvdyIvImVzIXc&input=)
```
R;H"ldor w /"er!"
T"Le!ll,o""\"tsiw
```
[Try it online!](http://fission.tryitonline.net/#code=UjtIImxkb3IgdyAvImVyISIKVCJMZSFsbCxvIiJcInRzaXc&input=)
### Explanation
This one is actually the simplest of the Fission solutions yet. In both programs there are two entry points: `R` creates a right-going atom and `L` a left-going atom. In either case, the `;` destroys one of them immediately.
Now in the `Hello, world!` program, the atom first prints half the string with `"Hello, "`, then `\` and `/` (which are mirrors) deflect the atom onto the second line going left. `"world!"` (read in the direction of the moving atom) prints the rest of the string. `L` is now a no-op and `;` destroys this atom as well, terminating the program.
The `Twister!` program is essentially the same but rotated by 180 degrees. This time, the `L` atom survives, and starts printing with `"Twist"`. The `\` and `/` again deflect it onto the other line, now going right. `"er!` prints the remainder of the string, `R` is a no-op and `;` terminates the program.
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~33~~ ~~31~~ 29 [bytes](https://github.com/DennisMitchell/jelly/blob/master/docs/code-page.md)
### Original
```
“ɗ⁻%OḶ$“¡¦ḟṠ»Ṫ
“ɗ⁻%OḶ$“¡¦ḟṠ»Ḣ
```
[Try it online.](http://jelly.tryitonline.net/#code=4oCcyZfigbslT-G4tiTigJzCocKm4bif4bmgwrvhuaoK4oCcyZfigbslT-G4tiTigJzCocKm4bif4bmgwrvhuKI&input=)
### Twisted
```
“ɗ⁻%OḶ$“¡¦ḟṠ»Ḣ
“ɗ⁻%OḶ$“¡¦ḟṠ»Ṫ
```
[Try it online!](http://jelly.tryitonline.net/#code=4oCcyZfigbslT-G4tiTigJzCocKm4bif4bmgwrvhuKIK4oCcyZfigbslT-G4tiTigJzCocKm4bif4bmgwrvhuao&input=)
### How it works
In each program, each line defines a link. The last one is the main link, and it is executed when the program starts. Since there are no references to the first link, it is simply ignored.
For both programs, `“ɗ⁻%OḶ$“¡¦ḟṠ»` yields the list `['Hello, world!', 'Twister!']`, using [Jelly's static dictionary compression](https://codegolf.stackexchange.com/a/70932).
The only difference between the original and the twisted code is the last character of the main link. `Ḣ` selects the first string of the list, and `Ṫ` selects the last one.
[Answer]
# Fission, 53
```
R"Hello, world!";
R;."..!..!!.!".\.
.;T..w..i".se.t/.
```
[Try it online!](http://fission.tryitonline.net/#code=UiJIZWxsbywgd29ybGQhIjsKUjsuIi4uIS4uISEuISIuXC4KLjtULi53Li5pIi5zZS50Ly4&input=)
and twisted:
```
R;.e..o..w..l..".
R"T"lw!,i!os!dt\;
.;H..l.. "!re"!/.
```
[Try it online!](http://fission.tryitonline.net/#code=UjsuZS4uby4udy4ubC4uIi4KUiJUImx3ISxpIW9zIWR0XDsKLjtILi5sLi4gIiFyZSIhLy4&input=)
[Answer]
# Japt, ~~67~~ ~~61~~ 57 bytes
*Saved 6 bytes thanks to @JAtkin, 4 bytes thanks to @Ian*
```
"Tzwzizsztzezzzzzzrzzzz!"rz;
"Hzezlzlzoz,z zwzorlzdz!"rz;
```
Twisted:
```
"Hzezlzlzoz,z zwzorlzdz!"rz;
"Tzwzizsztzezzzzzzrzzzz!"rz;
```
Test it online: [Original](http://ethproductions.github.io/japt?v=master&code=IlR6d3ppenN6dHplenp6enp6cnp6enohInJ6OwoiSHplemx6bHpveix6IHp3em9ybHpkeiEicno7&input=), [Twisted](http://ethproductions.github.io/japt?v=master&code=Ikh6ZXpsemx6b3oseiB6d3pvcmx6ZHohInJ6OwoiVHp3eml6c3p0emV6enp6enpyenp6eiEicno7&input=)
### How it works
```
"Tzwzizsztzezzzzzzrzzzz!"rz;  // Take this string and remove all "z"s.
"Hzezlzlzoz,z zwzorlzdz!"rz;  // Take this string and remove all "z"s.
                              // Implicit: output *last* expression
```
[Answer]
# Python, 398 ~~414 380 456~~ bytes\*
Managed to update so that it is compliant with the rules, but I still hesitate to call this competitive. Since the commented lines are needed for it to run, I've included them in the byte count
~~This solution does not follow the rules, as it will print error messages in addition to the allowed output.~~ 
I just wanted to see if this could be done in python. It can, but it is *not* pretty.
```
print'Hello, world!'
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
#rint'Twister!'     
```
When twisted becomes
```
print'Twister!'
#rint'Twister!'
#rint'Twister!'
#rint'Twister!'
#rint'Twister!'
#rint'Twister!'
#rint'Hwister!'
#rint'Teister!'
#rint'Twlster!'
#rint'Twilter!'
#rint'Twisoer!'
#rint'Twist,r!'
#rint'Twiste !'
#rint'Twisterw'
#rint'Twister!o
#rint'Twister!'r
#rint'Twister!' l
#rint'Twister!'  d
#rint'Twister!'   !
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 87 bytes
## Untwisted
```
main(){puts(1?"Hello, world!":"Twister!");}
mai (){puts(0?"Hello, world!":"Twister!");}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPQ7O6oLSkWMPQXskjNScnX0ehPL8oJ0VRyUoppDyzuCS1SFFJ07qWC6hWAabWAL/a//8B "C (gcc) – Try It Online")
# Twisted
```
mai (){puts(1?"Hello, world!":"Twister!");}
main(){puts(0?"Hello, world!":"Twister!");}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MVNBQ7O6oLSkWMPQXskjNScnX0ehPL8oJ0VRyUoppDyzuCS1SFFJ07qWC6g2D6bWAL/a//8B "C (gcc) – Try It Online")
[Answer]
# Brainfuck, ~~467~~ ~~367~~ 285 bytes
## Untwisted
```
 +[  [[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.>>] [[--[<++++>--->+<]>-]<<<<.<<<-.<<+.>-.+.<----.>--.>>---.[-]]]
  [ -[[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.>>]+[[--[<++++>--->+<]>-]<<<<.<<<-.<<+.>-.+.<----.>--.>>---.[-]]]
```
[Try it online!](https://tio.run/##rY5BCoJRCIT3neLtxTnB4EXExf8HQQQtgs7/Gu0IJSii3wxzvo778/a@PvZelmtluodnhIV3kUVNbRWO0F0DMLNEFFW9Y1gHOcxANV5JvccrjLL4StggKcxh4Giju0GkV9VFWZb/MY79FGfvDw "brainfuck – Try It Online")
## Twisted
```
  [  [[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.>>] [[--[<++++>--->+<]>-]<<<<.<<<-.<<+.>-.+.<----.>--.>>---.[-]]]
 +[ -[[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.>>]+[[--[<++++>--->+<]>-]<<<<.<<<-.<<+.>-.+.<----.>--.>>---.[-]]]
```
[Try it online!](https://tio.run/##rY5BCoJRCIT3neLtxTnB4EXExf8HQQQtgs7/Gu0IJTqIfg6er@P@vL2vj73XSmW6h2eEhXeQRam6CkdoLgHMLBFFRfcY1kEOM1CNV1Lr8QqjLL4nbJAU5jBwbqOrQaRX1WVZLv/jO/bTO3t/AA "brainfuck – Try It Online")
]