Jelly, 6 bytes

BUT’2*

Try it online!

Explanation

BUT here is an explanation (note: I had assumed that we may only output the powers of 2 themselves and nothing else):

BUT’2* – Monadic link. Takes a number N as input. Example: 86

B      – Convert N to binary.                              [1, 0, 1, 0, 1, 1, 0]

 U     – Reverse.                                          [0, 1, 1, 0, 1, 0, 1]

  T    – Truthy indices.                                   [2, 3, 5, 7]

   ’   – Decrement.                                        [1, 2, 4, 6]

    2* – Raise 2 to that power.                            [2, 4, 16, 64]

"Proof" that it works correctly. The standard representation of an integer $
X$ in base 2 is a list ${x_1, x_2, x_3,cdots, x_n}$, where $x_iin{0,1},:forall:: iinoverline{1,n}$, such that:
$$X=sum_{i=1}^n x_icdot 2^{n-i}$$
The indices $i$ such that $x_i=0$ obviously have no contribution so we're only interested in finding those such that $x_i=1$. Since subtracting $i$ from $n$ is not convenient (the powers of two all have exponents of the form $n-i$, where $i$ is any index of a $1$), instead of finding the truthy indices in this list we reverse it and then find them "backwards" with UT. Now that we've found the correct indices all we have to do is raise $2$ to those powers.

JavaScript (ES6), 28 bytes

f=n=>n?[...f(n&~-n),n&-n]:

Try it online!

Jelly, 4 bytes

-2 since we may output zeros in place of unused powers of 2 :)

Ḷ2*&

Try it online!

PowerShell, 45 bytes

param($a)7..0|%{'2*'*$_+'1'|iex}|?{$_-band$a}

Try it online!

Takes input $a, loops from 7 to 0, each iteration performing a string-multiplication of 2*, so for example for 3 this would be 2*2*2*, plus a 1 tacked on the end, so 2*2*2*1. That's piped to iex (short for Invoke-Expression and similar to eval) to formulate the powers-of-two. We then pull out those ? (where) the number $_ shares a value -binaryand with the input number.

APL (Dyalog Extended), 7 bytes^SBCS

Anonymous tacit prefix function. Requires 0-based indexing (⎕IO←0).

2*⍸⍢⌽⍤⊤

Try it online!

2 two
* raised to the power of
⍸ the ɩndices where true
⍢ while
⌽ reversed
⍤ of
⊤ the binary representation

Python 2, 43 40 bytes

f=lambda n,p=1:n/p*[1]and f(n,p*2)+[p&n]

Try it online!

Catholicon, 3 bytes

ṫĊŻ

Explanation:

ṫ       Decompose         into the largest values where:

 Ċ               the input

  Ż       the bit count is truthy (equal to one)

Wolfram Language 58 bytes

Flatten[2^#&/@(Position[Reverse@IntegerDigits[#,2],1]-1)]&

IntegerDigits[#,2] returns the binary representation of the input, #, as a list of 1's and 0's.

Reverse@ reverses that list.

(Position[...,1]-1) lists the positions of the 1's in the reversed list and decrements each position by 1.

2^#&/@ 2 is raised to the power of (position -1) for each integer in the list.

Flatten removes nested braces.

Retina 0.8.2, 25 bytes

.+

$*

M!`(G1|11)*1

%`1

Try it online! Explanation:

.+

$*

Convert to unary.

M!`(G1|11)*1

Match as many powers of 2 as possible, and then an extra 1. This gives a total sum of the next power of 2. The regular expression is greedy (default), so tries to consume the largest possible power of 2 at each match. The M! then causes the matches themselves to be listed on separate lines.

%`1

Convert each line back to decimal.

Python, 35 bytes

lambda n:[n&2**i for i in range(8)]

Little-endian with zeros at unused powers of 2.

Try it online!

Perl 6, 16 12 bytes

-4 bytes thanks to Jonathan Allan

*+&2**all ^8

Try it online!

Returns an All Junction with 8 elements. This is a rather non-standard way of returning, but generally, Junctions can act as ordered lists and it is possible to extract the values from one.

Explanation:

*+&              # Bitwise AND the input with

   2**           # 2 raised to the power of

      all ^8     # All of the range 0 to 7

Charcoal, 12 bytes

Ｉ⮌Ｅ⮌↨Ｎ²×ιＸ²κ

Try it online! Link is to verbose version of code. Includes zero values (+2 bytes to remove). Explanation:

     Ｎ          Input number

    ↨           Converted to base (MSB first)

      ²         Literal 2

   ⮌            Reversed (i.e. LSB first)

  Ｅ             Map over bits

        ι       Current bit

       ×        Multiplied by

          ²     Literal 2

         Ｘ      Raised to power

           κ    Current index

 ⮌              Reversed (back to MSB first)

Ｉ               Cast to string

                Implicitly print on separate lines

MATL, 5 bytes

BPfqW

Try it online!

Explanation

Consider input 86 as an example.

B    % Implicit input. Convert to binary (highest to lowest digits)

     % STACK: [1 0 1 0 1 1 0]

P    % Flip

     % STACK: [0 1 1 0 1 0 1]

f    % Find: indices of nonzeros (1-based)

     % STACK: [2 3 5 7]

q    % Subtract 1, element-wise

     % STACK: [1 2 4 6]

W    % Exponential with base 2, element-wise. Implicit display

     % STACK: [2 4 16 64]

Wolfram Language (Mathematica), 17 bytes

#~NumberExpand~2&

Try it online!

Mathematica strikes again.

Pure Bash, 20

echo $[2**{7..0}&$1]

Try it online!

Sledgehammer 0.2, 3 bytes

⡔⡸⢣

Decompresses into {intLiteral[2],call[NumberExpand,2]}.

Sledgehammer is a compressor for Wolfram Language code using Braille as a code page. The actual size of the above is 2.75 bytes, but due to current rules on meta, padding to the nearest byte is counted in code size.

Japt, 8 5 bytes

Æ&2pX

Try it

Original

¤¬ÔðÍm!²

Try it

¢¬ÔË*2pE

Try it

05AB1E, 9 bytes

Loʒ›}æʒOQ

Try it online!

This is also correct for 6-bytes, but it doesn't complete in time on TIO for 86:

05AB1E, 6 bytes

LoæʒOQ

Try it online!

Alchemist, 274 bytes

_->9a+In_x+s

s+a->s+b+c

s+x->s+y+z

s+0a+0x+b->b+d+m

s+0a+0x+0b->n+e

d+m->d+2n

d+0m->e

e+n->e+m

e+0n+b->d

e+0n+0b->h

h+m->h+u+v

h+0m->t

t+y+u->t

t+0y+u->f

t+y+0u->g+p

t+0y+0u->p

g+0p+z+v->g

g+0v->f

f+c->f+a

f+z->f+x

f+u->f

f+v->f

f+y->f

f+0v+0u+0z+0c+0y+a->s

p->Out_v+Out_" "

Try it online!