It's simple: Make a proper quine where if you remove any character, it's still a quine.

The difference between this and a radiation hardened quine is that if your program is AB, in a radiation hardened quine A would output AB, but here, A would output A.

Code golf, all standard rules, standard loopholes apply, no cheating.

  • \$\begingroup\$ Is an empty program valid? \$\endgroup\$
    – xenia
    Commented Feb 20, 2016 at 7:06
  • 4
    \$\begingroup\$ @Loovjo No. \$\endgroup\$ Commented Feb 20, 2016 at 9:55
  • 3
    \$\begingroup\$ @feersum The challenge states "Make a quine where...", so AB should output AB. \$\endgroup\$
    – user45941
    Commented Feb 21, 2016 at 4:54
  • 1
    \$\begingroup\$ @Mego I know it says that, but specifications are not always so precise, and it is not indicated in the examples. \$\endgroup\$
    – feersum
    Commented Feb 21, 2016 at 5:20
  • 4
    \$\begingroup\$ @feersum "Make a quine" means make a quine. "The difference between this and a radiation-hardened quine..." means that the only difference is that the program with any one byte removed results in a quine, not a program that prints the original program's source. There is no ambiguity here. \$\endgroup\$
    – user45941
    Commented Feb 21, 2016 at 5:24

2 Answers 2


Lenguage, 4.54×10761 bytes

It has this number of null characters:


Seeing how the criterion in this challenge conflicts with the definition of a "proper quine", seriously, I think an Unary variant is going to win.

Expanded Brainfuck code:


If one character is removed from the Lenguage program, the last character becomes a <, which causes the program to print exactly one less character.

  • 1
    \$\begingroup\$ How did you manage to find that fixed point? (Or alternatively, how does the Brainfuck code work?) \$\endgroup\$ Commented Feb 21, 2016 at 9:54
  • 1
    \$\begingroup\$ @MartinBüttner The first big loop copies and encodes the data in the form of ">+++..." (and reverses it). The other big loop print the data as an integer in unary. It's not that complicated but is long only because it's Brainfuck. \$\endgroup\$
    – jimmy23013
    Commented Feb 21, 2016 at 11:11
  • \$\begingroup\$ Oh right, so it's just like a plain Brainfuck quine, but with a different decoding function? \$\endgroup\$ Commented Feb 21, 2016 at 11:13
  • \$\begingroup\$ @MartinBüttner Somewhat. But half of the program is the "decoding function". \$\endgroup\$
    – jimmy23013
    Commented Feb 21, 2016 at 11:17
  • \$\begingroup\$ It seems you could use a similar technique to construct answers of arbitrary score for codegolf.stackexchange.com/q/57257/8478 (although how exactly that works would depend on the answer to my latest comment). \$\endgroup\$ Commented Feb 21, 2016 at 17:03

><> (Fish), 145 107 bytes

This answer uses ><>'s jumping instruction to fix the problem.


This quine actually contains two different quine generators. It starts with some jumping logic and by default uses the left quine. If a character is removed from the jumping logic or from the left quine, the program jumps to the right quine.

You can try it here


The code can be dissected into a few parts:

A: !<0078*+00~..>0[!. 
B:              >0[!."r43a*+8a+&{ee+00&1-:&(?.~~ol?!;4b*0.
C:                                                    .0f<
D:                                                        >0['r3d*159*+&}7a*00&1-:&(?.~~ol?!;68a*+0.
E:                                                                                                 .0+*a58 

Explanation of the different parts:

  • A: Jumps to the right of C. If any character is deleted from from A, this jumps to the left of D or the right of E, triggering the second quine. If any character is deleted from B or C, the code is shifted 1 character to the left, causing this to jump to the left of D.
  • C: This code jumps to the left of B.
  • B: Quine #1
  • D: Quine #2
  • E: Jumps to the left of D

Explanation of the quine (with #1 as example):

Once the instruction pointer reaches either of the quines, you're certain that that quine is completely intact.

>0[!.                                       //Fix the instruction pointer's direction and empty the stack (The '!.' is a leftover from codepart A)
     "r43a*+                                //Start reading all of the code and add the '"' character to the stack
            8a+&                            //Because the quine started reading at the 19th character instead of the first, the stack has to move 18 characters. 
                                            //This part saves the number 18 to the register.
                {ee+00&1-:&(?.              //Move the stack one to the left, decrease the stack by 1. If the stack is not empty yet, jump back to the start of this section.
                              ~~              //Clean the temporary variables from the stack. It should now contain the whole quine.
                                ol?!;4b*0.  //Print the first character from the stack. As long as the stack isn't empty, jump back to the start of this section.
  • \$\begingroup\$ Explanation please. \$\endgroup\$ Commented Jun 12, 2017 at 19:49
  • \$\begingroup\$ Reiterating above. \$\endgroup\$ Commented Jun 22, 2017 at 3:53
  • 1
    \$\begingroup\$ Is this clear enough? \$\endgroup\$ Commented Jun 22, 2017 at 8:09

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.