Vyxal, 45 bits^v2, 5.625 bytes

8ẇvB\.j

Try it Online!

7 bytes -> 5.625 bytes.

Explained

8ẇvB\.j­⁡​‎‎⁡⁠⁡‏⁠‎⁡⁠⁢‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁣‏⁠‎⁡⁠⁤‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁢⁡‏⁠‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁣‏‏​⁡⁠⁡‌­
8ẇ       # ‎⁡Split into chunks of length 8
  vB     # ‎⁢Convert each to binary. Pretty sure it should work without the v. Could be a bug
    \.j  # ‎⁣Join on "."s
💎

Created with the help of Luminespire.

Thunno 2, 6 bytes

8ẇḂ'.j

Try it online!

4ẆḂ'.j

Try it online!

Explanation

         # Implicit input
 ẇ       # Split the input into
8        # chunks of length eight
 Ẇ       # Or, split the input into
4        # four equal-sized chunks
  Ḃ      # Then, convert each from binary
   '.j  '# And join the list by "."s
         # Implicit output

Lua, 82 bytes

print(io.read():gsub(("%d"):rep(8),function(n)return'.'..tonumber(n,2)end):sub(2))

Try it online!

Takes input from stdin and writes to stdout. Works on Lua 5.0+.

This works by using string.gsub's ability to replace matches using a helper function. The function used here replaces a string of eight binary digits with a . followed by the digits in decimal. The :sub(2) at the end removes the extraneous . at the beginning of the resulting string.

Un-golfed version + extra explanation:

print(                                       -- print
    string.sub(                              --  substring
        string.gsub(                         --   replace
            io.read(),                       --    in string
            "%d%d%d%d%d%d%d%d",              --    replace
            function(n)                      --    with
                return                       --     result of
                    '.' ..                   --      concatenate with
                    tonumber(                --      string to number
                        n,                   --       convert this
                        2                    --       with base
                    )
            end
        ),
        2                                    --   starting at character (1-index)
    )
)

Fortran (GFortran), 58 bytes

integer i(4)                 !Declare 4 int array
read('(4B8)'),i              !Read as 4 length 8 binary numbers
print('(3(i0,"."),i0)'),i    !Print as 3 auto-length ints followed by a '.' and then the last int
end

Try it online!

Julia, 58 52 bytes

x->join(parse.(Int,x[n:n+7] for n=1:8:25;base=2),:.)

Takes the input string and uses a comprehension to create an array of the 8 bits. Then parses each element (via 'broadcasting' with the . into an Int. Last step is to join with the period.

Reductions per comments below:

• 4 byte reduction by simplifying the comprehension indexing
• 1 byte reduction in changing the separator from a string to a symbol (which join converts into a string upon joining with the integers)

PHP, 26 bytes

<?=long2ip(bindec($argn));

Try it online!

OR taking input as a integer as an anonymous function :

PHP, 7 bytes

long2ip

Try it online!

Forth (gforth), 130 bytes.

Requires a Forth that starts in decimal mode, works with gforth.

: p . 8 emit ." ." ;
: d dup 255 and swap ;      
: r 8 rshift d ;
: q 32 2 base ! word number drop d r r r drop decimal p p p . ;

Try it online!

Usage: q 10001011111100010111110001111110 [enter]

Deobfuscated version (or how I would really do it)

\ Forth program to convert a binary IP address to dotted decimal notation.

decimal
: binary   2 base ! ;

\ Get the binary string and convert to a number.
: getbin   32 binary word number drop ;

\ Shift and mask the byte we are interested in. Put all 4 on the stack.
hex
: mask   rshift dup ff and ;
: quad4   dup ff and swap ;
: quad   8 mask swap ;
: 3more   quad quad quad ;

\ Print a quad, backspace over it's trailing space, print a dot.
: .quad   . 8 emit ." ." ;

\ Print all 4 quads in decimal.
: .4quads   decimal .quad .quad .quad . ;

\ Get binary number, chop it up into 4 quads, print in decimal.
: qdot   getbin quad4 3more drop .4quads ;

REXX, 91 bytes

PARSE ARG WITH 1 A 9 B 17 C 25 D
SAY X2D(B2X(A))'.'X2D(B2X(B))'.'X2D(B2X(C))'.'X2D(B2X(D))

Online REXX interpreter

J, 18 bytes

' .'rplc~&":_8#.\]

Try it online!

Old answer

-2 thanks to Kritixi Lithos

' .'rplc~&":2#.4 8$]

Try it online!

My first answer in a non-esolang! (kinda). The way this answer works is pretty simple. Let's look first at a non-tacit form of this expression:

(":#.(4 8 $ n))rplc' .'

Assuming that (for instance) n is:

n =: 1 0 0 0 1 0 1 1 1 1 1 1 0 0 0 1 0 1 1 1 1 1 0 0 0 1 1 1 1 1 1 0 

The expression 4 8 $ n is equal to:

1 0 0 0 1 0 1 1
1 1 1 1 0 0 0 1
0 1 1 1 1 1 0 0
0 1 1 1 1 1 1 0

Then, the #. verb is applied over the matrix, yielding the following result:

139 241 124 126

The resulting list is stringified using ":, and using rplc every space in the string representation of list is swapped to a dot, yielding the final form:

139.241.124.126

Python 3 (125 bytes)

def f(x):
    y=''
    for j in range(4):
        y+=str(int(x[j*8:j*8+8],2))
        if j<4:
            y+="."
    return y

Try it online

Excel. 96 bytes

=BIN2DEC(LEFT(A1,8))&"."&BIN2DEC(MID(A1,9,8))&"."&BIN2DEC(MID(A1,17,8))&"."&BIN2DEC(RIGHT(A1,8))

Perl 6, 28 27 bytes

-1 byte thanks to Jo King

{chop S:g/.**8/{:2(~$/)}./}

Try it online!

Ruby, 37 34 bytes

->b{(-3..0).map{|w|255&b<<w*8}*?.}

Try it online!

Ruby -p, 34 bytes

Replaces each 8-character subsequence with its decimal conversion plus a dot, then removes the last dot.

gsub(/.{8}/){"#{$&.to_i 2}."}
chop

Try it online!

Perl, 33 bytes

$_=join'.',unpack'C4',pack'B*',$_

Try it online!

Read in right-to-left order:

1. Encode input using pack
2. Extract four unsigned bytes with unpack
3. Intercalate . separators with join

Python 3, 44 bytes

Another one using to_bytes trick, but this one also uses f-strings.

'.'.join(f"{b}"for b in n.to_bytes(4,"big"))

Haskell, 52 bytes

s n|(y,x)<-divMod n 256=concat[s y++"."|y>0]++show x

Try it online!

Takes input as number. Repeatedly divMods by 256 until the div is zero.

Java 9, 97 94 92 81 bytes

s->{for(int i=0;i<32;)System.out.print((i>0?".":"")+Long.parseLong(s,i,i+=8,2));}

-2 bytes thanks to @AZTECCO.
-11 bytes thanks to @Holger by combining the Long.parseLong(s.substring(i,i+=8),2) into Long.parseLong(s,i,i+=8,2).

Try it online.

Explanation:

s->{                   // Method with String parameter and no return-type
  for(int i=0;i<32;)   //  Loop `i` in the range [0, 32):
    System.out.print(  //   Print:
      (i>0?            //    If `i` is larger than 0 (so it's not the first iteration):
        "."            //     Print a dot
       :               //    Else:
        "")            //     Print nothing instead
      +                //    Appended with:
       Long.parseLong(s,i,i+=8,2));}
                       //     A substring of the input `s` from index `i` to `i+8`,
                       //     (and increase `i` by 8 for the next loop iteration)
                       //     Converted from binary-String to integer

C#7+, 117 73 bytes

s=>string.Join('.',(new System.Net.IPAddress(s)+"").Split('.').Reverse())

Accepts the bit representation of an IP address to transform it into a four-number notation, converts it to a string array, reverses the elements to account for the endianness differences of machines, then joins them together again with a dot.

Try it online!

• Reduced to 73 bytes by utilizing the string hack and chaining (c/o @Expired Data)

Initial answer, 117 bytes

string I(long b){var x=new System.Net.IPAddress(b).ToString().Split('.');Array.Reverse(x);return string.Join(".",x);}

Use it like:

void Main()
{
    Console.WriteLine(I(0b_10001011111100010111110001111110));
}

public string I(long b)
{
    var x = new System.Net.IPAddress(b).ToString().Split('.');
    Array.Reverse(x);
    return string.Join(".", x);
}

Perl 5, 30 bytes

s/.{8}/oct("0b$&").'.'/ge;chop

Try it online!

Search-replaces with regexp that takes eight bits (0 or 1) at a time and converts them to their decimal representation with . placed after each, but chops off the last . char. Using a function named oct here seems counter-intuitive since the input string isn't octal. But when the given string starts with 0b the rest is read as the binary string it is.

JavaScript (V8), 49 44 bytes

-5 bytes thanks to Arnauld

s=>s.match(/.{8}/g).map(x=>'0b'+x|0).join`.`

Try it online!

PowerShell, 45 44 bytes

$args|%{$r+=+$r+"$_"}
[ipaddress]::Parse($r)

Try it online!

PowerShell, 45 bytes

Pure PowerShell. It does not use external libs.

($args|%{($r=2*$r%256+"$_")[++$i%8]})-join'.'

Try it online!

Unrolled and commented:

$bytes = $args|%{           # $args is array on character 48 or 49 (bits)
    $r = 2 * $r             # one bit shift left
                            # the first operand is integer, so Powershell converts the second operand to an integer
    $r = $r % 256           # bitwise and 0xFF
    $digit = "$_"           # convert a char 48, 49 to string "0" or "1" respectively
    $r = $r + $digit        # add a digit
                            # the first operand is integer, so Powershell converts the second operand to an integer
    # now $r is a byte containing 8 bits to the left of the current one

    $index = ++$i % 8       # 1,2,3,4,5,6,7,0, 1,2,3,4,5,6,7,0, ...
    ($r)[$index]            # represent $r as an array; take an element of this array
                            # index 0 will give $r, other indexes will give $null
                            # Powershell outputs non $null values only
                            # Compare to `Wrtie-Output ($r)[$index]`
}
# now $bytes is array of not $null elements
Write-Output ($bytes -join '.')

C (gcc), 48 bytes

i;f(n){for(i=4;i--;)printf(".%hhu"+i/3,n>>i*8);}

Takes as input a 32-bit integer.

Thanks to ceilingcat and gastropner for getting this answer where it is now!

Try it online!

APL (Dyalog Unicode), 20 19 bytes^SBCS

-1 thanks to Kritixi Lithos.

Full program. Prompts for 32-bit integer, optionally as list of bits.

' '⎕R'.'⍕256|83⎕DR⎕

Try it online!

⎕ console prompt for numeric input

83⎕DR interpret the bits of that data as 8-bit integers (internal Data Representation type 3)

256| convert to unsigned integers (lit. 256-mod of that)

⍕ stringify (makes space-separated string)

' '⎕R'.' Replace spaces with dots

Python 2, 47 bytes

f=lambda n,k=-2:k*`n`or f(n>>8,k+1)+'.'+`n%256`

Try it online!

Python 3, 46 bytes

lambda n:('.%d'*4%(*n.to_bytes(4,"big"),))[1:]

Try it online!

Shaving a byte from David Foerster's to_bytes solution using string formatting.

Python 3, 47 bytes

lambda n:".".join(map(str,n.to_bytes(4,"big")))

Try it online!

x86-16 machine code, IBM PC DOS, 54 47 45 bytes

Binary:

00000000: be82 00b3 04b1 08ac d0d8 d0d4 e2f9 8ac4  ................
00000010: 41d4 0a50 8ac4 84c0 75f6 580c 30b4 0ecd  A..P....u.X.0...
00000020: 10e2 f74b 7406 b02e cd10 ebd9 c3         ...Kt........

Build and test BIN2IP.COM using xxd -r from above.

Unassembled listing:

BE 0082     MOV  SI, 82H        ; command line input address
B3 04       MOV  BL, 4          ; loop 4 bytes 
        BYTE_LOOP:
B1 08       MOV  CL, 8          ; loop 8 bits 
        BIT_LOOP: 
AC          LODSB               ; load next bit char into AL 
D0 D8       RCR  AL, 1          ; put LSB of char into CF 
D0 D4       RCL  AH, 1          ; put CF into LSB of byte value, then shift left
E2 F9       LOOP BIT_LOOP       ; continue bit loop 
8A C4       MOV  AL, AH         ; put byte result into AL
        GET_DIGIT: 
D4 0A       AAM                 ; byte divide by 10, AH = AL / 10, AL = AL % 10 
50          PUSH AX             ; save remainder in AL on stack 
8A C4       MOV  AL, AH         ; put quotient back into AL 
41          INC  CX             ; increment decimal digit count 
D4 C0       TEST AL, AL         ; quotient = 0? 
75 F6       JNZ  GET_DIGIT      ; if not, continue looping 
        PRINT_DIGIT: 
58          POP  AX             ; restore digit in AL 
0C 30       OR   AL, '0'        ; ASCII convert              
B4 0E       MOV  AH, 0EH        ; BIOS write char function   
CD 10       INT  10H            ; write to console 
E2 F7       LOOP PRINT_DIGIT    ; loop until done 
4B          DEC  BX             ; is last byte? 
74 06       JZ   END_LOOP       ; if so, don't display a '.' 
B0 2E       MOV  AL, '.'        ; otherwise display '.'
CD 10       INT  10H            ; write to console 
        END_LOOP:
75 D7       JNZ  BYTE_LOOP      ; continue byte loop 
C3          RET                 ; exit to DOS 

Output:

A standalone PC DOS executable. Input is command line, output to console.

Notes:

The "interesting part" (converting binary string to bytes) is about 15 bytes, whereas the rest of code is writing the itoa() function to convert binary bytes into a decimal string representation for display.

• -2 bytes eliminating unnecessary PUSH/POP thx to @PeterCordes!

k4, 18 17 bytes

saved a byte by expressing in composed form instead of as a lambda:

("."/:$2/:'4 0N#)

original explanation: output is string, quad-dot decimal not supported by k

{"."/:$2/:'4 0N#x}

{                } /lambda with implicit arg x
           4 0N#x  /cut x into 4 pieces
       2/:'        /convert each piece to decimal
      $            /stringify
 "."/:             /join with .

called on 2 binaries:

{"."/:$2/:'4 0N#x}'(10001011111100010111110001111110b;11000000101010000000000111111111b)
("139.241.124.126";"192.168.1.255")

CJam, 10 bytes

l~8/2fb'.*

Try it online!

Explanation

l~    e# Read a line and evaluate it. Pushes list to the stack
8/    e# Split into sublists of 8 elements each. Gives list of sublists
2fb   e# Map "base conversion" with extra parameter 2 over the list of sublists
'.*   e# Join sublists with character ".". Implicitly display

SmileBASIC, 49 bytes

INPUT X
RGBREAD X OUT A,B,C,D?A;".";B;".";C;".";D

Takes a decimal integer as input

the RGB and RGBREAD functions were designed to convert between 32 bit ARGB color values and separate 8 bit channels

Pyth, 10 9 bytes

j\.iR2cz8

Try it online!

Chops input into pieces of length 8 (cz8), then maps int(x, 2) over the result (iR2). Then just joins those with a dot separator (j\.).

-1 by using a more specialized map (R) instead of the generic m.

C (clang), 66 61 bytes

i;g(*m){for(i=32;i--;)*++m+=i%8?*m*2:!printf(".%d"+i/24,*m);}

Try it online!

Input as an array of integers (bits)

Adds current number shifted to the next. Every 8 bits it prints instead of adding.

Saved 5 thanks to @gastropner and @ceilingcat

[C (gcc clang)], 97 85 77 bytes

x;f(*s){x=strtoul(s,s,2);printf("%hhu.%hhu.%hhu.%hhu\n",x>>24,x>>16,x>>8,x);}

Try it online!

This version takes a string as input. 8 bytes shaved off thanks to JL2210!

Python 2, ^{81 \$\cdots\$ 58} 55 bytes

lambda s:'.'.join(`int(s[i:i+8],2)`for i in(0,8,16,24))

Try it online!

Saved 3 bytes thanks to ElPedro!!!

Lambda function that takes a string of 32 "0"s and "1"s.

Alchemist, 97 bytes

_->3a+7b+i
i+n->i+m
i+0n->j+In_n
j+m->j+2n
j+0m+b->i
j+0m+0b->k+Out_n
k+n->k
k+0n+a->7b+i+Out_"."

Try it online!

a and b count down the bytes and bits remaining, respectively. i, j, and k are phase/step atoms. The current byte is stored in n, with temporary storage in m.

Japt, 7 bytes

ò8 mÍq.

Try it here

PowerShell, 46 bytes

""+[IPAddress]"$([Convert]::ToInt64($args,2))"

Try it online!

First takes input $args binary string and [System.Convert]s it into Int64. Uses the .NET type call [System.Net.Ipaddress] to parse that Int64 into an IPAddress object, then coerces the .IPAddressToString() method by prepending ""+.

GolfScript, 20 bytes

8/{1/{~}%2base}%'.'*

Try it online!

Explanation

8/                   # Split into size 8 chunks
  {           }%     # For-each over the chunks
   1/                # Split into size-1 chunks
     {~}%            # Convert each from string to number
         2base       # Convert to base 10
                '.'* # Join with dots

MathGolf, 6 bytes

8/å'.u

Try it online.

Explanation:

8/       # Split the (implicit) input-string into parts of size 8
  å      # Convert each part from a binary-string to an integer
   '.u  '# Join by "."
         # (after which the entire stack joined together is output implicitly)

Stax, 8 bytes

Ç∩0&→Ö¡ 

Run and debug it at staxlang.xyz!

Unpacked (9 bytes) and explanation:

8/{|Bm'.*
8/           Split into length-8 chunks. 4M would work just as well.
  {|Bm       Convert each chunk to decimal
      '.*    Join with .

Jelly, 10 6 bytes

s8Ḅj“.

Try it online!

s            Slice input list
 8           into size 8 chunks
  Ḅ          Convert from binary list to integer
   j“.       Join with dots as the separator
             Implicit output

Burlesque, 13 bytes

8co{b2}]m'.IC

Try it online!

8co    #Break into chunks 8 long
{b2}]m #Read each chunk as base-2 and turn to string
'.IC   #Intercalate "." between each and collapse

05AB1E, 6 bytes

4äC'.ý

Try it online or verify all test cases.

Explanation:

4ä       # Convert the (implicit) input-string into 4 equal-sized parts
  C      # Convert each part from binary to an integer
   '.ý  '# Join this list by "."
         # (after which the result is output implicitly)

Red, 33 bytes

func[n][to 1.1.1 debase/base n 2]

Try it online!

Takes the input as strings.

Batch, 56 bytes

@for /f "tokens=2" %%f in ('ping %1')do @echo %%f&exit/b

Takes input as the first command-line argument. Somewhat slow, but -n1 -w1 can be added to the ping command to speed it up a bit.