[Question]
  [
# Challenge
Write a program or function that converts a 32 bit binary number to its [quad-dotted decimal](https://en.wikipedia.org/wiki/Dot-decimal_notation) notation (often used for representing IPv4)
# Quad-dotted decimal
A quad-dotted decimal is formed like so:
1. Split the binary representation into its 4 individual bytes
2. Convert each byte into denary
3. place "." between each number
Example:
```
input:  10001011111100010111110001111110
step 1: 10001011 11110001 01111100 01111110
step 2:    139      241      124      126
step 3: 139.241.124.126
```
# I/O examples
```
input --> output
10001011111100010111110001111110 --> 139.241.124.126
00000000000000000000000000000000 --> 0.0.0.0
01111111000000000000000000000001 --> 127.0.0.1
11000000101010000000000111111111 --> 192.168.1.255
```
# Rules
* Input will always be a 32 bit binary number or a binary list or string
* [Standard I/O](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) rules apply
* No [standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default)
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins
  
[Answer]
# 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:**
[![enter image description here](https://i.stack.imgur.com/JQKyh.png)](https://i.stack.imgur.com/JQKyh.png)
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()`](https://en.wikibooks.org/wiki/C_Programming/stdlib.h/itoa) function to convert binary bytes into a decimal string representation for display.
* -2 bytes eliminating unnecessary `PUSH/POP` thx to @PeterCordes!
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
4äC'.ý
```
[Try it online](https://tio.run/##yy9OTMpM/f/f5PASZ3W9w3v//zc0MDAwNDAEAwQTxIIwAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkn3lf5PDS5zV9Q7v/a/z39DAwMDQwBAMEEwQC8LgMiAAuKAqDXHIG3LBpAzBECEBAwA).
**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)
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 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](https://codegolf.stackexchange.com/users/52904/ceilingcat) and [gastropner](https://codegolf.stackexchange.com/users/75886/gastropner) for getting this answer where it is now!*
[Try it online!](https://tio.run/##hY9BDoIwEEX3nKIhMbQq2gILkwmcxA2ilVlYSANuCGevpSiQKPF389M3r@kU4b0ojEGQVLFOVppimgCGIbBao2ok9Q@bsmz9HR7jvcoy3J4Y9MYi8shR0WeFV@Z1HrEZLrEWJCX8IjjngguXuQ5tLLAwImfwP1ka8WiI6f1fEUsjGX/1nhXuzJOfgOcUSe0aDEjdNkWZaxqcVcBgQtE6itdR8o0c07em1YrY/XrzAg "C (gcc) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~10~~ 6 bytes
```
s8Ḅj“.
```
[Try it online!](https://tio.run/##y0rNyan8/7/Y4uGOlqxHDXP0/v//H22oYwCGhmCMgNhEYWJIIrEA "Jelly – 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
```
[Answer]
# [PHP](https://php.net/), 26 bytes
```
<?=long2ip(bindec($argn));
```
[Try it online!](https://tio.run/##K8go@P/fxt42Jz8v3SizQCMpMy8lNVlDJbEoPU9T0/r/f0MDAwNDA0MwQDBBLAjjX35BSWZ@XvF/XTcA "PHP – Try It Online")
### OR taking input as a integer as an anonymous function :
# [PHP](https://php.net/), 7 bytes
```
long2ip
```
[Try it online!](https://tio.run/##K8go@G9jX5BRoMClkmb7Pyc/L90os@C/NVdqcka@gkqahkpiUXqepvV/I0NjA3MDMxNj43/5BSWZ@XnF/3XdAA "PHP – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 46 bytes
```
""+[IPAddress]"$([Convert]::ToInt64($args,2))"
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0lJO9ozwDElpSi1uDhWSUUj2jk/ryy1qCTWyiok3zOvxMxEQyWxKL1Yx0hTU@n////qhgYGBoYGhmCAYIJYEIY6AA "PowerShell – 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 `""+`.
[Answer]
# [Python 2](https://docs.python.org/2/), 47 bytes
```
f=lambda n,k=-2:k*`n`or f(n>>8,k+1)+'.'+`n%256`
```
[Try it online!](https://tio.run/##DcZLDoMgEADQPadg0whFG5hR/CR6FmxaIsGOxNA0PT3tW730zdtBUIqf9/V1f6yc6jg3MMWrI3ec3AtalqGOykhV3Srl6AKddeWzhf3JzZTOQFl4ESi9s5BSFsC2H7pR95ppBgb/sS0iQ0AAtBrNDw "Python 2 – Try It Online")
---
# [Python 3](https://docs.python.org/3/), 46 bytes
```
lambda n:('.%d'*4%(*n.to_bytes(4,"big"),))[1:]
```
[Try it online!](https://tio.run/##hYpBCoMwEEX3OcUQEDMSJNO6EjxJLUVR20A7CSYbT5@irbgqfbOYB@/7JT4cn9PUtOnZvfqhA65VXmZDXlSZKriM7tYvcQyq0rK3d4ka8UL1NdmXd3OEsAThZ8tRFWpS6w8aTogwuRkCWF4XZYiDZdQQRt/IliUmMsaQoY1DV/uIMH8Q3yX96CT2RNsdYecN "Python 3 – Try It Online")
Shaving a byte from [David Foerster's `to_bytes` solution](https://codegolf.stackexchange.com/a/197958/20260) using string formatting.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 6 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
8/å'.u
```
[Try it online.](https://tio.run/##y00syUjPz0n7/99C//BSdb3S//@VDA0MDAwNDMEAwQSxIAwlLiUDAgCkxBBuAjZgCFQCkzQEQ4QUDCgBAA)
**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)
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~20~~ 19 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
-1 thanks to Kritixi Lithos.
Full program. Prompts for 32-bit integer, optionally as list of bits.
```
' '⎕R'.'⍕256|83⎕DR⎕
```
[Try it online!](https://tio.run/##pZCxCsIwEIb3PsVtnSq5xKZ9ABdX3yBoFKG2tUmFipugRVBcBBdfLi9SNVBbSwfBfFzg/sv93EWkkTcrRJQsKlMe08oF11xumTtwzflGfb4L2SsfTV7X@4EzjjWj5nA1pz0BRpkp77YO5vyAWE6lUiIrQCeQZnIjYw0i14mn1rmUWwnJHNRKRBEsY60qsCd1EIgFbTT0qbXWUpzah8BftHywZ45fQafZ67sXW9HT1@XjYz8dKFKKGPjodwqkkyMPgoANWUf2kHMeDkPyBA "APL (Dyalog Unicode) – Try It Online")
`⎕` console prompt for numeric input
`83⎕DR` interpret the bits of that data as **8**-bit integers (internal **D**ata **R**epresentation type **3**)
`256|` convert to unsigned integers (lit. 256-mod of that)
`⍕` stringify (makes space-separated string)
`' '⎕R'.'` **R**eplace spaces with dots
[Answer]
# [JavaScript (V8)](https://v8.dev/), ~~49~~ 44 bytes
*-5 bytes thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)*
```
s=>s.match(/.{8}/g).map(x=>'0b'+x|0).join`.`
```
[Try it online!](https://tio.run/##RcdLCoAgFEDRrUQTlej1nDWxtWjSF8tIkaBau/0G3dG5owrK6XVYfB7KaBqftCI6UTmYlNc9LWAvz6Jj9y50ExXBmmTbgQxGO8wSZNR2dtY0YGxHW5pyROTI334@@pAyFi8 "JavaScript (V8) – Try It Online")
[Answer]
# 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!](https://tio.run/##Sy7WTS7O/O9WmpdsU5qZV6KjUFxSlJmXbqeQpmD7v9jWDsLV88rPzNNQ11PX0chLLVcIriwuSc3V80st0fMMcExJKUotLtYo1tRWUtLUCy7IySwBKdXUC0otSy0qTtXQ1PxvzcUVADSoRCNNwyAp3tDAwMDQwBAMEEwQC8IAagAA)
* 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);
}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 7 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ò8 mÍq.
```
[Try it here](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=8jggbc1xLg&input=IjEwMDAxMDExMTExMTAwMDEwMTExMTEwMDAxMTExMTEwIg)
[Answer]
# 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")
```
[Answer]
# 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.](https://tio.run/##hVFBbsMgELznFStOIDsIkksV1@kH2lxyrHqgDok2dbBlcKQq8ttdjHGjupW6SGh2mWVm4ayuank@fPRFqayFF4XmtgBA43RzVIWG3ZACXCs8QEH3rkFzAssyX@0WfrNOOSxgBwZy6O1yeztWDfX9gLnI8HG9ytj@0zp94VXreO37HaW4FU@Ekw0hLHmuzInXqrF6QNSmmGKSP6QrxrKuzwaRun0vvUjUCl4u3mm08/oGio02nbaOEimEkEKGuMMBjYAE@xNb/BMztvy@96@QP9kTT4Z1Z00xYxPe6ForR9fD8LMnDmMHYvwFNHXr4uC/njgcJmQDk4ThxViM@byjNDRKdv0X)
**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
```
[Answer]
## Excel. 96 bytes
```
=BIN2DEC(LEFT(A1,8))&"."&BIN2DEC(MID(A1,9,8))&"."&BIN2DEC(MID(A1,17,8))&"."&BIN2DEC(RIGHT(A1,8))
```
[Answer]
# 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](https://tio.run/##RY3BCsIwEETv/Yqll@xakUR7KMV8iXgQTDQ5pGUbofn62MZiBwYeuzPMmOJ7CJecn8aCxZn6ChYlLUQBOzB4cAH4EV4G2@1fMo2eIqMLEeebP3T94qa7H89E/4yz4K/t3tl69akuJzbxwwFSdlooKaWSqmjHlX4gqpHXLYuOKOcv)
[Answer]
# [Red](http://www.red-lang.org), 33 bytes
```
func[n][to 1.1.1 debase/base n 2]
```
[Try it online!](https://tio.run/##hYyxDsIwDERn8hWWd8DuyMBHsFoeSuOoLC4K5fvTJqh0QeKdZJ11p8sWy82iaEgXKOntg7jKPAGfVkG0e/@ycz3g0GlJU7Z@GNdHkImIiRu7re5jMByQ/tA6/N34BdfOlnLTnm1gUIFnfvgM4oDHK0ICVy0L "Red – Try It Online")
Takes the input as strings.
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 13 bytes
```
8co{b2}]m'.IC
```
[Try it online!](https://tio.run/##SyotykktLixN/f/fIjm/OsmoNjZXXc/T@f9/QwMDA0MDQzBAMEEsCAMA "Burlesque – 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
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 8 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
Ç∩0&→Ö¡ 
```
[Run and debug it at staxlang.xyz!](https://staxlang.xyz/#p=80ef30261a99ad20&i=%2210001011111100010111110001111110%22%0A%2200000000000000000000000000000000%22%0A%2201111111000000000000000000000001%22%0A%2211000000101010000000000111111111%22&a=1&m=2)
### 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 .
```
[Answer]
# [Python 2](https://docs.python.org/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!](https://tio.run/##hU9BCsIwELznFaGXJhjKbhApgb5EhVY0GNGmNLn4@phNqb0Izh52lhmWmekd737UyXan9Bxel@vAg6mbunl4N4rejVGEozNu156Vlr31M3c8K6BahQel91KmeAsxdILxCgEAAQs2Smwhlcom@IPFhN8vv4DFtMpYZhNXkEkyykwRc@yyg2F8mqmZFXTnBh8 "Python 2 – Try It Online")
Saved 3 bytes thanks to [ElPedro](https://codegolf.stackexchange.com/users/56555/elpedro)!!!
Lambda function that takes a string of 32 `"0"`s and `"1"`s.
[Answer]
# [C (clang)](http://clang.llvm.org/), ~~66~~ 61 bytes
```
i;g(*m){for(i=32;i--;)*++m+=i%8?*m*2:!printf(".%d"+i/24,*m);}
```
[Try it online!](https://tio.run/##hU5db8IwDHz3r7hVQiQthDh8DJZV@yGIh660EIl2qBTtAfHbuzQr4mmarShn@3znfJqfsvrQdc4eRFzJW/nVCJfOjXXTqZVxklRJ6kbrj7iKzdvLuXF1W4pIjfZR4mZmMfE79t75LqrM1ULiRsiPWYPPa1kWzRZLjZ0l9AzsszbbYm76DuH76E4FBBhpikue1aVANLpEmAzLkJBeDv4mT@sVHFJoWP@/9zIWSeIgPWWQdth5xsM6VCnGPO7tcBCBBenPwfnaXrxdFKo7gdAU7bWpoS3diWYx8XyjzIIVm4V/K9IqJLF5DYiJN0bxaq1YmeWS4lnHWmvWHOIJe/QLSP8TNDD5j7n3HEYc8jl4xA8 "C (clang) – 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 
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 10 bytes
```
l~8/2fb'.*
```
[Try it online!](https://tio.run/##S85KzP3/P6fOQt8oLUldT@v//2hDBQMwNARjBMQmChNDEokFAA "CJam – 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
```
[Answer]
# [Python 3](https://docs.python.org/3/), 47 bytes
```
lambda n:".".join(map(str,n.to_bytes(4,"big")))
```
[Try it online!](https://tio.run/##hYpBCsIwEEX3OcWQVUZCSNSV4E0K0tJWI3YSMrPp6SOtlq7EN4t58H6e5ZHoVMdrU1/t1PUt0EU77Z4pkpnabFiKJSfp1s0ysDlb3cW7RsQap5yKAM@scokk5mBGs3y2cESEMRVgiLQsHEsfCS3wkK@6IY01eO@DDyu7LvYR5f@gvsvwowe1pbDeHjbe "Python 3 – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~45~~ 44 bytes
```
$args|%{$r+=+$r+"$_"}
[ipaddress]::Parse($r)
```
[Try it online!](https://tio.run/##hZDLCsIwEEX3@YpQRttiDZlYXwXBT3AvItXGBxStiaJS@@01pta6ELxDwiUzJwM3O16l0juZpiVs6ITmJcRqqx@tHFRn0jGXA0unIPN9FieJklovomgWKy09UH5ZEDL1CDUKPBc558jRqrEvVxk3oC72xkyEyFCE5gxcv4b5H71gzmx9QfjZ9ktoN4qhxbDBagBtNeO1LDYWDAcjhkz0@wb16YO2aG6/gNX@EKt7QEHeMrk@y8QkB8uqZzK6pGfz0DaBTqtJ23HAeze78vQh/ahGHFKUTw "PowerShell – Try It Online")
---
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 45 bytes
Pure PowerShell. It does not use external libs.
```
($args|%{($r=2*$r%256+"$_")[++$i%8]})-join'.'
```
[Try it online!](https://tio.run/##hZBha4MwEIa/@yuCnE0ybcil6uyg4P8oo3Rb1jmkdbGjHepvt2mctR8Ge4/AS9577uCqw0mb@kOXZQ/vZEWansHW7Oo2aBiYlXoAE6gkDX3Y@HwdhlAE2XPH55@HYk8F7TvPy5lHrCJGUUqJEp0me3WDoRGhuFgKFaNAFduXUj7C8h9dYSlc3UF42/aX0G1Ujw7DCRsBdDW1j3LYUglMM4FCJYlFOWlJQBo3Al6K/db8RAT0udKvR/1mTwebITO6/i6P9mNmL5oPnS7xgf2Gc/11I/nTiPhe118A "PowerShell – 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 '.')
```
[Answer]
# [Perl 5](https://www.perl.org/), 30 bytes
```
s/.{8}/oct("0b$&").'.'/ge;chop
```
[Try it online!](https://tio.run/##K0gtyjH9/79YX6/aolY/P7lEQ8kgSUVNSVNPXU9dPz3VOjkjv@D/f0MDAwNDA0MwQDBBLAiDy4AA4IKqNMQhb8gFkzIEQ4QEDPzLLyjJzM8r/q9bkAMA "Perl 5 – 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 `chop`s 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.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~37~~ 34 bytes
```
->b{(-3..0).map{|w|255&b<<w*8}*?.}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6pWkPXWE/PQFMvN7Gguqa8xsjUVC3JxqZcy6JWy16v9n@BQlq0QZKhgYGBoYEhGCCYIBaEEfsfAA "Ruby – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~28~~ 27 bytes
*-1 byte thanks to Jo King*
```
{chop S:g/.**8/{:2(~$/)}./}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/Ojkjv0Ah2CpdX09Ly0K/2spIo05FX7NWT7/2f3FipYIeUFVafpGCDZehgYGBoYEhGCCYIBaEwWVAAHBBVRrikDfkgkkZgiFCAga47P4DAA "Perl 6 – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 18 bytes
```
' .'rplc~&":_8#.\]
```
[Try it online!](https://tio.run/##y/r/P83WSl1BT72oICe5Tk3JKt5CWS8m9n9qcka@QpqCoYIBGBqCMQJiE4WJIYv8BwA "J – Try It Online")
## Old answer
-2 thanks to Kritixi Lithos
```
' .'rplc~&":2#.4 8$]
```
[Try it online!](https://tio.run/##y/r/P83WSkNdQU@9qCAnuU5NycpIWc9EwUIlVvN/anJGvkKagoGCIQo0IAkackGNgWk0RDMQmyhMDFnkPwA "J – 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
```
[Answer]
# 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](https://www.tutorialspoint.com/execute_rexx_online.php)
[Answer]
# [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 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!](https://tio.run/##hY1BDoMgEEX3nuK3@xqgMWl02Rt4AyxQTarioPH4FLDWTZO@IeGT/8KYkeb28jTx8r6ERY4bdN/NyM/xVFkJBbVYiKKAHBTcKi0qJEJJwSfXdmYOXrQnXAUEGuk0TlhHUhiWvtEERaMNEqXZHvrR9fIV1tq0uvITOGOMM544YkxbyO51NoH94WPx7z@/4Ju19zzN0e74Nw "Forth (gforth) – 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 ;
```
]