Your task, if you wish to accept it, is to write a program that outputs its own source code in the binary UTF-8 representation.


  • The source must be at least 1 byte long.

  • Your program must not take input (or have an unused, empty input).

  • The output may be in any convient format.

  • Optional trailing newline is allowed.

  • Notice that one byte is 8 bits, and the length of the binary UTF-8 representation is necessarily a multiple of 8.

  • This is so all usual golfing rules apply, and the shortest code (in bytes) wins.

  • Standard loopholes are forbidden.


Let's say your source code is Aä$$€h, its corresponding UTF-8 binary representation is 010000011100001110100100001001000010010011100010100000101010110001101000.

If I run Aä$$€h the output must be 010000011100001110100100001001000010010011100010100000101010110001101000.

A      --> 01000001
ä      --> 1100001110100100
$      --> 00100100
$      --> 00100100
€      --> 111000101000001010101100
h      --> 01101000
Aä$$€h --> 010000011100001110100100001001000010010011100010100000101010110001101000

String to binary UTF-8 converters

  • 1
    \$\begingroup\$ By "binary", do you mean a string representation of the binary values, i.e. a string consisting of only 1's and 0's? \$\endgroup\$
    – user77406
    Commented Feb 4, 2019 at 18:38
  • 1
    \$\begingroup\$ @mdahmoune Now that's already much better. The question remains how to represent something as UTF-8. Notice that Unicode representation is mainly based on the looks of a character (only occasionally on semantic meaning). What if no assigned Unicode glyph looks like a character in the source code? Unicode also has many look-alikes (homoglyphs). How does one decide which one to use? E.g. Dyalog APL has an AND function which may be encoded as 01011110 or 0010011100100010 in UTF-8 (they look pretty alike: ^ vs ) \$\endgroup\$
    – Adám
    Commented Feb 4, 2019 at 19:44
  • 1
    \$\begingroup\$ Better example: 01111100 and 0010001100100010 encode | and . \$\endgroup\$
    – Adám
    Commented Feb 4, 2019 at 19:51
  • 4
    \$\begingroup\$ @Adám I think it would be fair to output any binary sequence that corresponds to a symbol that will compile/run in a certain implementation of a language. \$\endgroup\$
    – qwr
    Commented Feb 4, 2019 at 20:09
  • 1
    \$\begingroup\$ How about machine code? (Commodore C64 takes 28 bytes assuming the machine code itself is the "source") \$\endgroup\$ Commented Feb 4, 2019 at 21:18

15 Answers 15


V, 28 (or 16?) Latin 1 bytes (35 UTF-8 bytes)

ñéÑ~"qpx!!xxd -b

Try it online!

Hexdump (in Latin 1):

00000000: f1e9 d17e 2271 7078 2121 7878 6420 2d62  ...~"qpx!!xxd -b
00000010: 0ace 6457 3534 7c44 0acd dff3            ..dW54|D....

Output (binary representation of the same code in UTF-8, not Latin 1):



ñéÑ~"qpx            " Standard quine. Anything after this doesn't affect the
                    " program's 'quine-ness' unless it modifies text in the buffer
        !!xxd -b    " Run xxd in binary mode on the text
Î                   " On every line...
 dW                 "   delete a WORD
   54|              "   Go to the 54'th character on this line
      D             "   And delete everything after the cursor
Í                   " Remove on every line...
  ó                 "   Any whitespace
 ß                  "   Including newlines


V, 16 bytes

ñéÑ~"qpx!!xxd -b

Try it online!


00000000: 11000011 10110001 11000011 10101001 11000011 10010001  ......
00000006: 01111110 00100010 01110001 01110000 01111000 00100001  ~"qpx!
0000000c: 00100001 01111000 01111000 01100100 00100000 00101101  !xxd -
00000012: 01100010 00001010                                      b.

OP said:

The output may be in any convenient format.

This outputs in a much more convenient format for V :P (but I'm not sure if that's stretching the rules)


CJam, 20 bytes


Try it online!

Surprised to see CJam winning! we'll see how long that lasts...


05AB1E, 105 bytes


05AB1E has no UTF-8 conversion builtins, so I have to do everything manually..

Try it online or verify that it's a quine.



The shortest for 05AB1E is this one: 0"D34çý"D34çý (14 bytes) provided by @OliverNi. My answer uses a modified version of that quine by adding at the ... here: 0"D34çý..."D34çý.... A short explanation of this quine:

0               # Push a 0 to the stack (can be any digit)
 "D34çý"        # Push the string "D34çý" to the stack
        D       # Duplicate this string
         34ç    # Push 34 converted to an ASCII character to the stack: '"'
            ý   # Join everything on the stack (the 0 and both strings) by '"'
                # (output the result implicitly)

Challenge part:

Now for the challenge part of the code. As I mentioned at the top, 05AB1E has no UTF-8 conversion builtins, so I have to do these things manually. I've used this source as reference on how to do that: Manually converting unicode codepoints into UTF-8 and UTF-16. Here a short summary of that regarding the conversion of Unicode characters to Unicode†:

  1. Convert the unicode characters to their unicode values (i.e. "dЖ丽" becomes [100,1046,20029])
  2. Convert these unicode values to binary (i.e. [100,1046,20029] becomes ["1100100","10000010110","100111000111101"])
  3. Check in which of the following ranges the characters are:
    1. 0x00000000 - 0x0000007F (0-127): 0xxxxxxx
    2. 0x00000080 - 0x000007FF (128-2047): 110xxxxx 10xxxxxx
    3. 0x00000800 - 0x0000FFFF (2048-65535): 1110xxxx 10xxxxxx 10xxxxxx
    4. 0x00010000 - 0x001FFFFF (65536-2097151): 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

†: Unicode is capped at 21 bits, but UTF-8 is capped at 17 bits. So the range of 4 above would instead be:
0x00010000 - 0x0010FFFF (65536-1114111): 10000xxx 10xxxxxx 10xxxxxx 10xxxxxx

The character d will be in the first range, so 1 byte in UTF-8; character Ж is in the second range, so 2 bytes in UTF-8; and character is in the third range, so 3 bytes in UTF-8.

The x in the pattern behind it are filled with the binary of these characters, from right to left. So the d (1100100) with pattern 0xxxxxxx becomes 01100100; the Ж (10000010110) with pattern 110xxxxx 10xxxxxx becomes 11010000 10010110; and the (100111000111101) with pattern 1110xxxx 10xxxxxx 10xxxxxx becomes 1110x100 10111000 10111101, after which the remaining x are replaced with 0: 11100100 10111000 10111101.

So, that approach I also used in my code. Instead of checking the actual ranges, I just look at the length of the binary and compare it to the amount of x in the patterns however, since that saves a few bytes.

Ç               # Convert each character in the string to its unicode value
 b              # Convert each value to binary
  ε             # Map over these binary strings:
   Dg           #  Duplicate the string, and get its length
     •Xó•       #  Push compressed integer 8657
         18в    #  Converted to Base-18 as list: [1,8,12,17]
            @   #  Check for each if the length is >= to this value
                #  (1 if truthy; 0 if falsey)
   ƶ            #  Multiply each by their 1-based index
    à           #  Pop and get its maximum
     ©          #  Store it in the register (without popping)
   i            #  If it is exactly 1 (first range):
    7j          #   Add leading spaces to the binary to make it of length 7
      0ì        #   And prepend a "0"
   ë            #  Else (any of the other ranges):
    R           #   Reverse the binary
     6ô         #   Split it into parts of size 6
       Rí       #   Reverse it (and each individual part) back
    ć           #   Pop, and push the remainder and the head separated to the stack
     7®-        #   Calculate 7 minus the value from the register
        j       #   Add leading spaces to the head binary to make it of that length
         š      #   Add it at the start of the remainder-list again
    Tì          #   Prepend "10" before each part
      J         #   Join the list together
    1®<×        #   Repeat "1" the value from the register - 1 amount of times
        ì       #   Prepend that at the front
  ]             # Close both the if-else statement and map
   ð0:          # Replace all spaces with "0"
      J         # And join all modified binary strings together
                # (which is output implicitly - with trailing newline)

See this 05AB1E answer of mine (sections How to compress large integers? and How to compress integer lists?) to understand why •Xó•18в is [1,8,12,17].

  • 1
    \$\begingroup\$ ?:: 0x00010000 - 0x001FFFFF (65536-2097151): 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx this range is incorrect : UTF-8 codepoints that map to 4 bytes only go up to 4^8 + 4^10 - 1 \$\endgroup\$ Commented May 26, 2023 at 11:15
  • \$\begingroup\$ @RAREKpopManifesto It doesn't change my program, but you're indeed right. I've fixed the explanation. You may want to leave the same comment on the stackoverflow answer I copied it from. :) \$\endgroup\$ Commented May 26, 2023 at 11:51

JavaScript (Node.js), 60 bytes

-15 bytes from @Neil and @Shaggy


Try it online!

  • \$\begingroup\$ padStart(8,0) saves 2 bytes. \$\endgroup\$
    – Neil
    Commented Feb 4, 2019 at 21:57
  • \$\begingroup\$ The spec allows for output to be in any convenient format so you could keep the map and ditch the join to output an array of bits \$\endgroup\$
    – Shaggy
    Commented Feb 4, 2019 at 23:35
  • \$\begingroup\$ 60 bytes with output as an array of bytes. \$\endgroup\$
    – Shaggy
    Commented Feb 4, 2019 at 23:46
  • \$\begingroup\$ Thanks @Neil and @Shaggy!! \$\endgroup\$ Commented Feb 5, 2019 at 2:35

Perl 5, 42 bytes

$_=q(say unpack'B*',"\$_=q($_);eval");eval



Rust, 187 bytes

fn f(o:u8){for c in b"go!g)n;t9(zgns!b!ho!c#%#/huds)(zhg!b_n <27zqshou )#z;19c|#-b_n(:|dmrdzg)1(:|||go!l`ho)(zg)0(:|".iter(){if c^o!=36{print!("{:08b}",c^o);}else{f(0);}}}fn main(){f(1);}

Try it online!


Perl 6, 46 bytes

<say "<$_>~~.EVAL".ords.fmt("%08b",'')>~~.EVAL

Try it online!

The standard quine with .fmt("%08b",'') formats the list of ordinal values into length 8 binary and joins with an empty string.


Java 10, 339 308 265 227 225 186 184 bytes

v->{var s="v->{var s=%c%s%1$c;return 0+new java.math.BigInteger(s.format(s,34,s).getBytes()).toString(2);}";return 0+new java.math.BigInteger(s.format(s,34,s).getBytes()).toString(2);}

-8 bytes thanks to @NahuelFouilleul removing the unnecessary &255 (and an additional -35 for bringing to my attention that the full program specs of the challenge had been revoked and a function is allowed now as well..)
-41 bytes thanks to @OlivierGrégoire.

Try it online.



  • var s contains the unformatted source code String
  • %s is used to put this String into itself with s.format(...)
  • %c, %1$c and 34 are used to format the double-quotes (")
  • s.format(s,34,s) puts it all together

Challenge part:

v->{                         //  Method with empty unused parameter and String return-type
  var s="...";               //   Unformatted source code String
  return 0+                  //   Return, with a leading "0":
   new java.math.BigInteger( //    A BigInteger of:
     s.format(s,34,s)        //     The actual source code String
      .getBytes())           //     Converted to a list of bytes (UTF-8 by default)
   .toString(2);}            //    And convert this BigInteger to a binary-String      
  • 1
    \$\begingroup\$ 265 bytes using lambda, also because all source is ascii seems unsigned int c&255 is not needed \$\endgroup\$ Commented Feb 5, 2019 at 13:32
  • \$\begingroup\$ @NahuelFouilleul The original question stated "You must build a full program." and "Your output has to be printed to STDOUT.", hence the verbose border-plate code I have instead of a lambda function returning a String. Good point about not needing &255 however since we don't use any non-ASCII characters, thanks! \$\endgroup\$ Commented Feb 5, 2019 at 13:34
  • \$\begingroup\$ ok i'm not yet very familar with the usages, but other languages like javascript give a lambda returning a string, also i don't understand why in java we don't count the type and the final semicolon when using lambda where could i find rules? \$\endgroup\$ Commented Feb 5, 2019 at 13:44
  • 1
    \$\begingroup\$ Well, that's where I'm lost. However I tried and here's a new candidate for 184 bytes. Tell me if I'm wrong somewhere ;) \$\endgroup\$ Commented Feb 5, 2019 at 14:37
  • 1
    \$\begingroup\$ @OlivierGrégoire Ah, nice approach! Completely forgot about BigInteger being pretty short for converting to binary-Strings. And 2 more bytes by changing the return'0'+ to return 0+. Hmm, why is that leading 0 necessary btw? It confuses me that all inner binary-Strings have this leading 0, but the very first one not when using BigInteger.toString(2).. \$\endgroup\$ Commented Feb 5, 2019 at 14:44

Python 2, 68 67 bytes

_="print''.join(bin(256|ord(i))[3:]for i in'_=%r;exec _'%_)";exec _

Try it online!

A modification of this answer

-1 bytes by removing the space after 'in' (thanks @mdahmoune)

  • \$\begingroup\$ -1 byte: u can drop the space after in \$\endgroup\$
    – mdahmoune
    Commented Feb 5, 2019 at 18:24
  • \$\begingroup\$ you haven't updated your TIO link. also, I tried to do '%08b'%ord(i) instead of bin(256|ord(i))[3:], but it didn't work for some reason \$\endgroup\$
    – Jo King
    Commented Feb 6, 2019 at 9:50

R, 138 114 bytes


Try it online!

Uses R’s ability to deparse functions to their character representation. The revs are needed because rawToBits puts the least significant bit first. as.integer is needed because otherwise the bits are displayed with a leading zero.

Edited once I realised that any convenient output was allowed. Also was out by one on original byte count.


Python 3.8 (pre-release), 62 bytes

exec(a:="print(''.join(f'{i:08b}'for i in b'exec(a:=%r)'%a))")

Try it online!

How it work :

  • exec(a:="print('exec(a:=%r)'%a)") is a quine
  • f'{i:08b}' converts i into its 8-digits binary representation
  • b'example_string' is a binary sting. When we iterate over it, it convert the characters by their unicode value
  • ''.join( ... for i in ...) iterate over a string an concatenate the char after the transformation

C# (Visual C# Interactive Compiler), 221 bytes

var s="var s={0}{1}{0};Write(string.Concat(string.Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));";Write(string.Concat(string.Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));

Try it online!

C# (Visual C# Interactive Compiler) with flag /u:System.String, 193 bytes

var s="var s={0}{1}{0};Write(Concat(Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));";Write(Concat(Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));

Try it online!


Bash + GNU tools, 48 bytes

trap -- 'trap|xxd -b|cut -b9-64|tr -dc 01' EXIT


  • \$\begingroup\$ thanks, updated indeed it's the shortest variation otherwise should be removed from trap output \$\endgroup\$ Commented Feb 5, 2019 at 11:21

Ruby, 45 bytes

eval$b=%q[puts "eval$b=%q[#$b]".unpack("B*")]

Try it online!


Burlesque, 33 bytes

#Q/v(#Q)+]up~-' ;;\[{**b28'0lp}m[

Try it online!

#Q       # Push remaining stack to stack (Quine)
/v       # Drop input (empty string/whatever)
(#Q)+]up # #Q does not add itself. Complete quine, convert to string
~-       # Remove extraneous brackets
' ;;\[   # Remove extraneous spaces
 **      # get codepoint
 b2      # Convert to binary
 8'0lp   # Pad to 8 with 0s
}m[      # Apply to each char of quine

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.