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

ñéÑ~"qpx!!xxd -b

ÎdW54|D

Íßó

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):

110000111011000111000011101010011100001110010001011111100010001001110001011100000111100000100001001000010111100001111000011001000010000000101101011000100000110111000011100011100110010001010111001101010011010001111100010001000000110111000011100011011100001110011111110000111011001100001010

Explanation:

ñéÑ~"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

CJam, 20 bytes

{s"_~"+{i2b8Te[}%}_~

Try it online!

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

05AB1E, 105 bytes

0"D34çýÇbεDg•Xó•18в@ƶà©i7j0ìëR6ôRíć7®-jšTìJ1®<×ì]ð0:J"D34çýÇbεDg•Xó•18в@ƶà©i7j0ìëR6ôRíć7®-jšTìJ1®<×ì]ð0:J

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

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

Explanation:

quine-part:

The shortest quine 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 UTF-8:

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
      
   
   
   
   

There are also ranges for 5 or 6 bytes, but let's leave them out for now.

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].

JavaScript (Node.js), 60 bytes

-15 bytes from @Neil and @Shaggy

f=_=>[...Buffer(`f=`+f)].map(x=>x.toString(2).padStart(8,0))

Try it online!

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.

Perl 5, 42 bytes

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

TIO

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.

Explanation:

quine-part:

• 
  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      

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

TIO

Python 2, 100, 96 bytes

from inspect import*

print''.join(format(ord(x),'08b')for x in getsource(__import__(__name__)))

Try it online!

R, 137 bytes

x=function(){cat(as.integer(rev(rawToBits(rev(charToRaw(sprintf("x=%s;x()",gsub("\s","",paste(deparse(x),collapse="")))))))),sep="")};x()

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.

Try it online!

Shell script, 40 bytes

#!/bin/sh

xxd -b<"$0"|cut -b9-|tr -dc 01

Two additional bytes may be removed (the quote marks) if the filename doesn't contain spaces or special characters.

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)