[Question]
  [
Make a Windows style Loading bar by the following instructions. 
(notice that this is different than [Loading... Forever](https://codegolf.stackexchange.com/questions/101289/loading-forever))
Your output should start by `[.... ]`.
Every tick, you should wait 100 ms, then move each dots by one character right. if the dot is on the tenth character, move it to the first. Notice that you should clear the screen before outputting again. The output is ordered as the following:
```
[....      ]
[ ....     ]
[  ....    ]
[   ....   ]
[    ....  ]
[     .... ]
[      ....]
[.      ...]
[..      ..]
[...      .]
```
..Then it loops forever.
# Rules
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer wins I doubt I would even accept a winning answer tho
* Please provide a gif file of the loading bar in action if possible.
  
[Answer]
# V, ~~17~~ ~~16~~ 15 bytes
```
i[´.¶ ]<esc>ògó$X|p
```
`<esc>` is `0x1b`.
And the hexdump:
```
00000000: 695b b42e b620 5d1b f267 f324 587c 70    i[... ]..g.$X|p
```
### Explanation
```
i                       " Insert
[                       " a [
´.                      " 4 .s
¶<space>                " 6 spaces
]<esc>                  " and a ]. Then return to normal mode
ò                       " Recursively do:
 gó                     "  Sleep for 100 milliseconds
 $                      "  Go to the ]
 X                      "  Delete the character to the left of the ]
 |                      "  Go to the [
 p                      "  And paste the deleted character right after the [
                        " Implicit ending ò
```
[![gif](https://i.stack.imgur.com/mgkcN.gif)](https://i.stack.imgur.com/mgkcN.gif)
[Answer]
## CSS/HTML, ~~202~~ ~~190~~ 186 + 45 = ~~247~~ ~~235~~ 231 bytes
```
pre{position:relative}x{position:absolute;display:inline-block;width:10ch;height:1em;overflow:hidden}x>x{width:14ch;left:-10ch;animation:1s steps(10,end)infinite l}@keyframes l{to{left:0
```
```
<pre>[<x><x>....      ....</x></x>          ]
```
Edit: Saved ~~12~~ 14 bytes thanks to @Luke.
[Answer]
# PowerShell, ~~67~~ 66 Bytes
```
for($s='.'*4+' '*6;$s=-join($s[,9+0..8])){cls;"[$s]";sleep -m 100}
```
-1 by using shortened constructor thanks to Beatcracker
replaces the string with a copy of the string where the last char is put in front of the remaining chars, clears the screen, prints it, and then sleeps for 100 ms.
saved a lot of bytes by using the for loop constructor rather than wrap the logic inside the string.
[![enter image description here](https://i.stack.imgur.com/NbSVi.gif)](https://i.stack.imgur.com/NbSVi.gif)
[Answer]
# [Python 3](https://docs.python.org/3/), ~~99~~ ~~93~~ ~~85~~ 83+2 ([-u flag](https://stackoverflow.com/questions/230751/how-to-flush-output-of-python-print/230780#230780)) bytes
-12 bytes thanks to ovs  
-2 bytes thanks to totallyhuman
```
import time
s=4*'.'+6*' '
while 1:print(end='\r[%s]'%s);time.sleep(.1);s=s[9]+s[:9]
```
[Try it online!](https://tio.run/nexus/python3#FctBCoAgEADAu6/wEqsJghCBii8xby0kmIkr9Hyjuc/Md3v64CPfyChsK2hQ@woc2Hvlgty41nMdAusZ4OhxoQQLSf8HTQWxCW2kp0DRJkXR2TTnBw "Python 3 – TIO Nexus")
[Answer]
# Windows batch , ~~201~~ 181 bytes
*Turns out using the old-school method actually saves bytes!*
```
@for %%p in ("....      " " ....     " "  ....    " "   ....   " "    ....  " "     .... " "      ...." ".      ..." "..      .." "...      .")do @echo [%%~p]&timeout 0 >nul&cls
@%0
```
---
Note:
```
get-screenrecorder.level
- low grade
get-gpu.level
- horrible
if get-screenrecorder.level == low grade || get-gpu.level == horrible {
     say("GIF may not be accurate");
}
```
[![GIF!](https://i.stack.imgur.com/3udtf.gif)](https://i.stack.imgur.com/3udtf.gif)
Please note that my GIF recorder skipped a few frames, making the loading bar jumps `:(`
[Answer]
# Javascript (ES6), 86 bytes
```
setInterval('with(console)clear(),log(`[${x=x[9]+x.slice(0,9)}]`)',100,x='...      .')
```
[Answer]
## Mathematica, ~~67~~ 77 Bytes
+10 Bytes as I forgot the square brackets.
```
Animate["["<>"....      "~StringRotateRight~n<>"]",{n,1,10,1},RefreshRate->10]
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~126~~ ~~125~~ ~~124~~ ~~123~~ ~~122~~ ~~121~~ ~~119~~ ~~118~~ ~~117~~ ~~114~~ 115 bytes
This one uses a bitmask to keep track of where the dots are.
I had to add another byte as I was only outputting 5 spaces before.
```
m=30;f(i){usleep(3<<15);system("clear");for(i=1;i<1920;i*=2)putchar(i^1?i&m?46:32:91);m+=m&512?m+1:m;f(puts("]"));}
```
[Try it online!](https://tio.run/nexus/c-gcc#FYxBCoMwEAD/koPsVgpurAWzBl/SQggRA66K0YNIn92ztccZhjnFlgV3EPHY0hDCDGXTUIWc9rQGAeWH4BaF3E0LREscG6p1wfFmNc7b6nt3@Te1MZP28TSlNjUhS24lq0i3kpOR63@lCdRLIfLnFBdHwKODP3zH6e6d78MP "C (gcc) – TIO Nexus")
[![enter image description here](https://i.stack.imgur.com/jfdf2.gif)](https://i.stack.imgur.com/jfdf2.gif)
[Answer]
# JavaScript (ES6) + HTML, ~~104~~ ~~85~~ 83 bytes
```
f=(s="....      ")=>setTimeout(f,100,s[9]+s.slice(0,9),o.value=`[${s}]`)
<input id=o
```
* Saved 2 bytes thanks to [Johan](https://codegolf.stackexchange.com/users/55822/johan-karlsson)'s suggestion that I use an `input` instead of a `pre`.
---
## Try It
Requires a closing `>` on the `input` tag in order to function in a Snippet.
```
(f=(s="....      ")=>setTimeout(f,100,s[9]+s.slice(0,9),o.value=`[${s}]`))()
```
```
<input id=o>
```
[Answer]
# [Noodel](https://tkellehe.github.io/noodel/), ~~16~~ ~~15~~ ~~14~~ 13 [bytes](https://tkellehe.github.io/noodel/docs/code_page.html)
~~[ CỤ‘Ṁ~ððÐ]ʠḷẸḍt~~
~~]ʠ[Ð.×4¤×6⁺ḷẸḍt~~
~~]ʠ⁶¤⁴.ȧ[ėÐḷẸḍt~~
[Try it:)](https://tkellehe.github.io/noodel/editor.html?code=%5D%CA%A0%E2%81%B6%C2%A4%E2%81%B4.%C8%A7%5B%C4%97%C3%90%E1%B8%B7%E1%BA%B8%E1%B8%8Dt&input=&run=true)
---
## How it works
```
]ʠ⁶¤⁴.ȧ[ėÐḷẸḍt
]ʠ⁶¤⁴.ȧ[ėÐ     # Set up for the animation.
]              # Pushes the literal string "]" onto the stack.
 ʠ             # Move the top of the stack down by one such that the "]" will remain on top.
  ⁶¤           # Pushes the string "¤" six times onto the stack where "¤" represents a space.
    ⁴.         # Pushes the string "." four times onto the stack.
      ȧ        # Take everything on the stack and create an array.
       [       # Pushes on the string literal "[".
        ė      # Take what is on the top of the stack and place it at the bottom (moves the "[" to the bottom).
         Ð     # Pushes the stack to the screen which in Noodel means by reference.
          ḷẸḍt # The main animation loop.
          ḷ    # Loop endlessly the following code.
           Ẹ   # Take the last character of the array and move it to the front.
            ḍt # Delay for a tenth of a second.
               # Implicit end of loop.
```
---
## Update
```
[Ð]ıʠ⁶¤⁴.ḷėḍt
```
[Try it:)](https://tkellehe.github.io/noodel/editor.html?code=%5B%C3%90%5D%C4%B1%CA%A0%E2%81%B6%C2%A4%E2%81%B4.%E1%B8%B7%C4%97%E1%B8%8Dt&input=&run=true)
Don’t know why this took me a while to think of. Anyways, this places it at **13 bytes**.
```
[Ð]ıʠ⁶¤⁴.ḷėḍt
[Ð]ıʠ⁶¤⁴.     # Sets up the animation.
[             # Push on the character "["
 Ð            # Push the stack as an array (which is by reference) to the screen.
  ]           # Push on the character "]"
   ı          # Jump into a new stack placing the "[" on top.
    ʠ         # Move the top of the stack down one.
     ⁶¤       # Push on six spaces.
       ⁴.     # Push on four dots.
         ḷėḍt # The main loop that does the animation.
         ḷ    # Loop the following code endlessly.
          ė   # Take the top of the stack and put it at the bottom.
           ḍt # Delay for a tenth of a second.
```
```
<div id="noodel" code="[Ð]ıʠ⁶¤⁴.ḷėḍt" input="" cols="12" rows="2"></div>
<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>
```
[Answer]
# PHP, 67 bytes
```
for($s="...      .";$s=substr($s.$s,9,10);usleep(1e5))echo"\r[$s]";
```
no comment
[Answer]
# C#, 162 157 bytes
```
()=>{for(string o="[....      ]";;){o=o.Insert(1,o[10]+"").Remove(11,1);System.Console.Write(o);System.Threading.Thread.Sleep(100);System.Console.Clear();}};
```
or as whole program for 177 bytes
```
namespace System{class P{static void Main(){for(string o="[....      ]";;){o=o.Insert(1,o[10]+"").Remove(11,1);Console.Write(o);Threading.Thread.Sleep(100);Console.Clear();}}}}
```
[Answer]
# Pure bash, 68
```
s=${1:-....      }
printf "[$s]\r"
sleep .1
exec $0 "${s: -1}${s%?}"
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~28~~ 27 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ṙ©-j@⁾[]ṭ”ÆȮœS.1®ß
897ṃ⁾. Ç
```
[![Example run](https://i.stack.imgur.com/Esfsi.gif)](https://i.stack.imgur.com/Esfsi.gif)
### How?
```
ṙ©-j@⁾[]ṭ”ÆȮœS.1®ß - Link 1, the infinite loop: list of characters s
ṙ                  - rotate s left by:
  -                -   -1 (e.g. "...      ." -> "....      ")
 ©                 -   copy to the register and yield
     ⁾[]           - literal ['[',']']
   j@              - join with reversed @rguments
         ”Æ        - literal '\r'
        ṭ          - tack (append the display text to the '\r')
           Ȯ       - print with no newline ending
              .1   - literal 0.1
            œS     - sleep for 0.1 seconds then yield the printed text (unused)
                ®  - recall the value from the register
                 ß - call this link (1) again with the same arity
897ṃ⁾. Ç - Main link: no arguments
897      - literal 897
    ⁾.   - literal ['.',' ']
   ṃ     - base decompression: convert 897 to base ['.',' '] = "...      ."
```
[Answer]
# C (gcc), ~~202~~ ~~198~~ ~~196~~ ~~189~~ ~~96~~ ~~99~~ ~~88~~ ~~86~~ ~~79~~ ~~77~~ ~~75~~ ~~74~~ 73 bytes
Saved ~~7~~ 8 bytes thanks to [Digital Trauma](/a/120322/61563).
```
f(i){usleep(dprintf(2,"\r[%-10.10s]","....      ...."+i%10)<<13);f(i+9);}
```
Or, if your system's `stdout` doesn't need to be flushed after every write without a newline:
# C (gcc), 70 bytes
```
f(i){usleep(printf("\r[%-10.10s]","....      ...."+i%10)<<13);f(i+9);}
```
### How it works
* `usleep(` sleeps for the next return value in microseconds.
* `dprintf(2,` prints to file descriptor 2, or `stderr`. This is necessary because while `stdout` is line-buffered (meaning output will not show until it prints a newline), `stderr` is character-buffered (all output is shown immediately).
* `"\r` prints a carriage return (clears the current line).
* `[%-10.10s]"` is the `printf` format specifier for a string with exact length 10 (no matter what string provided the output will always be a string with length 10), padded with spaces to the right if necessary. This will be enclosed with brackets.
* `".... ...."` is the loading bar.
* `+i%10` offsets the loading bar by the current index modulo 10. For example, if `i == 3`, `i % 10` is equal to 3. Offsetting the loading bar by 3 makes it equal to `". ...."`.
* When the offset-ed string is passed to the `printf` format specifier, it limits to a length of 10 if necessary and adds spaces to the end if necessary. Therefore, the loading bar will always be between `[.... ]` and `[. ...]`.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 24 bytes
```
`1&Xx'['897B@YS46*93hhDT
```
Try it at [**MATL Online!**](https://matl.io/?code=%601%26Xx%27%5B%27897B%40YS46%2a93hhDT&inputs=&version=19.10.0) Or see a gif from the offline compiler:
[![enter image description here](https://i.stack.imgur.com/e9D9Z.gif)](https://i.stack.imgur.com/e9D9Z.gif)
### Explanation
```
`        % Do...while
  1&Xx   %   Pause for 0.1 s and clear screen
  '['    %   Push this character
  897B   %   Push [1 1 1 0 0 0 0 0 0 1]
  @      %   Push current iteration index, 1-based
  YS     %   Circularly shift the array by that amount
  46*    %   Multiply by 46 (code point of '.')
  93     %   Push 93 (code point of ']')
  hh     %   Concatenate horizontally twice. Numbers are interpreted as chars
         %   with the corresponding code points
  D      %   Display
  T      %   Push true. Used as loop condition. Results in an infinite loop
         % End (implicit)
```
[Answer]
# Java 7, ~~139~~ 124 bytes
```
String s="....      ";void c()throws Exception{System.out.print("["+s+"]\r");s=(s+s).substring(9,19);Thread.sleep(100);c();}
```
* Mentioning of `\r` thanks to *@Phoenix*.
The carriage return `\r` resets the 'cursor' back to the begin of the line, which can then be overwritten. Unfortunately, online compilers nor the Eclipse IDE doesn't support this, so I've added a gif at the end of this answer to show it from Windows Command Prompt.
[Try it here.](https://tio.run/nexus/java-openjdk#bY@xboMwGIR3nuLkpbZIHaKqQ@QydOiYKd3SDA52iyWwEb8JiSKenTp0TG856aQ7fVc1mgi7WwY4H@HKYtXqS/nyqrBe490Ya0AB1zDABP8UUeuzhUZ0rX0OQ5z3sXf@B1QymYRFTJ2DM6i4iHUfRsLHpbJddMHf9leKtpWpKbtUjJwdWE45O371TCgqOeUkJA0nWnb5drXZCvVZ91YbSY21Hd8UhVCZ@@Yuz98SrHggHf8jzRKOmmagG06Nq0BRx2QLaaud539PDkdogQfu7P7L2xE7LuR9KQVTNs2/) (Slightly modified so you won't have to wait for the time-out before viewing the result. Also, the TIO doesn't support carriage returns, so every line is printed without overwriting the previous line.)
**Explanation:**
```
String s="....      ";            // Starting String "....      " on class level
void c()                          // Method without parameter nor return-type
 throws Exception{                // throws-clause/try-catch is mandatory for Thread.sleep
  System.out.print("["+s+"]\r");  //  Print the String between square-brackets,
                                  //  and reset the 'cursor' to the start of the line
  s=(s+s).substring(9,19);        //  Set `s` to the next String in line
  Thread.sleep(100);              //  Wait 100 ms
  c();                            //  Recursive call to same method
}                                 // End of method
```
**Output gif:**
[![enter image description here](https://i.stack.imgur.com/QgUUd.gif)](https://i.stack.imgur.com/QgUUd.gif)
[Answer]
# [Python 2](https://docs.python.org/2/), ~~81~~ 78 bytes
-1 byte (noticing I missed use of `%s` when Rod submitted an [almost identical Python 3 version](https://codegolf.stackexchange.com/a/120236/53748) at the same time!)  
-2 bytes (using [totallyhuman's idea](https://codegolf.stackexchange.com/questions/120216/loading-forever-windows-style/120235#comment295545_120236) - replace `s[-1]+s[:-1]` with `s[9]+s[:9]`)
```
import time
s='.'*4+' '*6
while s:print'\r[%s]'%s,;s=s[9]+s[:9];time.sleep(.1)
```
[![Example run](https://i.stack.imgur.com/9wqCb.gif)](https://i.stack.imgur.com/9wqCb.gif)
[Answer]
# [Go](https://golang.org/), ~~150~~ ~~145~~ ~~132~~ ~~129~~ 124 bytes
*-5 bytes thanks to sudee.*
I feel like I don't see enough Go here... But my answer is topping C so... pls halp golf?
```
package main
import(."fmt"
."time")
func main(){s:="....      ";for{Print("\r["+s+"]");Sleep(Duration(1e8));s=(s+s)[9:19];}}
```
[Try it online!](https://tio.run/nexus/go#Hcq7CsMgFADQ3a8Id/IiFbI1kWz9gEDHNIPItZXWB2qmkM/ubEvOfFrS5q2f1HntAnM@xVy5BOsrMAnVeQJkdgvmDBz3Mk4g/7oTKBvzPmcXKodHXkAUASugun@IEr9tWVcXA@/piqjKxIsouAxjP6zqOFr7hngx2rzoBw "Go – TIO Nexus")
[Answer]
# VBA 32-bit, ~~159~~ ~~157~~ ~~143~~ ~~141~~ 134 Bytes
VBA does not have a built in function that allows for waiting for time periods less than one second so we must declare a function from `kernel32.dll`
**32 Bit Declare Statement (41 Bytes)**
```
Declare Sub Sleep Lib"kernel32"(ByVal M&)
```
**64 Bit Declare Statement (49 Bytes)**
```
Declare PtrSafe Sub Sleep Lib"kernel32"(ByVal M&)
```
Additionally, we must include a `DoEvents` flag to avoid the infinite loop from making Excel appear as non-responsive. The final function is then a subroutine which takes no input and outputs to the VBE immediate window.
**Immediate Window function, 93 Bytes**
Anonymous VBE immediate window function that takes no input and outputs to the range `A1` on the ActiveSheet
```
s="...      ....      .":Do:DoEvents:Sleep 100:[A1]="["&Mid(s,10-i,10)&"]":i=(i+1)Mod 10:Loop
```
### Old Version, 109 Bytes
Immediate window function that takes no input and outputs to the VBE immediate window.
```
s="...      ....      .":i=0:Do:DoEvents:Sleep 100:Debug.?"["&Mid(s,10-i,10)&"]":i=(i+1) Mod 10:Loop
```
**Ungolfted and formatted**
```
Declare PtrSafe Sub Sleep Lib "kernel32" (ByVal M&)
Sub a()
    Dim i As Integer, s As String
    s = "...      ....      ."
    i = 0
    Do
        Debug.Print [REPT(CHAR(10),99]; "["; Mid(s, 10 - i, 10); "]"
        DoEvents
        Sleep 100
        i = (i + 1) Mod 10
    Loop
End Sub
```
*-2 Bytes for removing whitespace*
*-30 Bytes for counting correctly*
*-14 Bytes for converting to immediate window function*
**Output**
*The gif below uses the full subroutine version because I was too lazy to rerecord this with the immediate window function.*
[![VBA loading Gif](https://i.stack.imgur.com/zCSuM.gif)](https://i.stack.imgur.com/zCSuM.gif)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 23 bytes
```
'.4×ð6×J[D…[ÿ],Á¶т×,т.W
```
[Try it online!](https://tio.run/nexus/05ab1e#ASUA2v//Jy40w5fDsDbDl0pbROKAplvDv10sw4HCttGCw5cs0YIuV/// "05AB1E – TIO Nexus")
**Explanation**
```
'.4×ð6×J                  # push the string "....      "
        [                 # forever do:
         D                # duplicate
          …[ÿ],           # interpolate the copy between brackets and print
               Á          # rotate the remaining copy right
                ¶т×,      # print 100 newlines
                    т.W   # wait 100ms
```
[Answer]
# Batch, ~~99~~ 98 bytes
*Saved 1 byte thanks to SteveFest!*
(I could remove `\r` from the code, but in the spirit of batch golfing, I won't.)
```
@SET s=....      
:g
@CLS
@ECHO [%s%]
@SET s=%s:~-1%%s:~,-1%
@ping 0 -n 1 -w 100>nul
@GOTO g
```
[![Recorded with LICEcap](https://i.stack.imgur.com/H2nrN.gif)](https://i.stack.imgur.com/H2nrN.gif)
There are four spaces after the first line.
The main logic is modifying the string. `%s:~-1%` is the last character of `%s%` and `%s:~0,-1%` is all but the last character of `%s%`. Thus, we are moving the last character to the front of the string, which rotates the string.
[Answer]
# Ruby, ~~57~~ 56 bytes
```
s=?.*4+' '*6;loop{$><<"[%s]\r"%s=s[-1]+s.chop;sleep 0.1}
```
Heavily influenced by other answers here.
Saved a byte thanks to @manatwork. Also apparently I have trouble counting characters -- I use ST3 and apparently it will include newlines in the count of characters in the line if you're not attentive.
[Answer]
# Perl, 69 bytes
*-3 bytes thanks to [@Dom Hastings](https://codegolf.stackexchange.com/users/9365/dom-hastings).*
```
$_="....".$"x6;{print"\ec[$_]
";select$a,$a,!s/(.*)(.)/$2$1/,.1;redo}
```
That `select undef,undef,undef,.1` is the shortest way to sleep less than 1 second in Perl, and it takes a lot of bytes...
---
Slightly longer (79 bytes), there is: 
```
@F=((".")x4,($")x6);{print"\ec[",@F,"]\n";@F=@F[9,0..8];select$a,$a,$a,.1;redo}
```
[Answer]
# Bash, ~~93~~ ~~90~~ 96 bytes
```
s="...      ....      ."
for((;;)){ for i in {0..9};do printf "\r[${s:10-i:10}]";sleep .1;done;}
```
[view here](https://asciinema.org/a/4b02bns85e01zev7jqdhx6vdx)
couldn't get nested { } in for syntax
[Answer]
# Groovy, 72 bytes
```
s="*"*4+" "*6
for(;;){print("["+s+"]"+"\n"*20);s=s[9]+s[0..8];sleep 100}
```
**Explaination**
```
s="*"*4+" "*6 //creates the string "****      "
for(;;){ //classic infinite loop
    print("["+s+"]"+"\n"*20) //prints the string with [ at the beginning and ] at the end. After that some newlines
    s=s[9]+s[0..8] //appends the final char of the string to beginning, creating a cycling illusion
    sleep 100 //100 ms delay
}
```
[Answer]
# Haskell (Windows), 159 bytes
```
import System.Process
import Control.Concurrent
main=mapM id[do system"cls";putStrLn('[':["....      "!!mod(i-n)10|i<-[0..9]]++"]");threadDelay(10^5)|n<-[0..]]
```
Explanation
```
mapM id             sequentially perform each IO action in the following list
[                   start a list comprehension where each element is...
  do                  an IO operation where
    system "cls";       we clear the screen by calling the windows builtin "cls"
    putStrLn(           then display the string...
      '[':                with '[' appended to
      [                   a list comprehension where each character is...
        "....      "!!       the character in literal string "....      " at the index
        mod(i-n)10          (i - n) % 10
      |i<-[0..9]]         where i goes from 0 to 9
      ++"]"             and that ends with ']'
    );
    threadDelay(10^5)   then sleep for 100,000 microseconds (100 ms)
|n<-[0..]]          where n starts at 0 and increments without bound
```
Haskell's purity made generating the cycling dot pattern somewhat complex. I ended up creating a nested list comprehension that generated an infinite list of strings in the order they should be output, then went back added the appropriate IO operations.
[Answer]
# Ruby, 61 bytes
If the spec were for the dots to scroll left instead of right, it would save 1 byte because `rotate!` with no arguments shifts the array once to the left.
```
s=[?.]*4+[' ']*6
loop{print ?[,*s,"]\r";s.rotate!9;sleep 0.1}
```
[Answer]
# GNU sed (with exec extension), 64
Score includes +1 for `-r` flag.
```
s/^/[....      ]/
:
esleep .1
s/[^. ]*(.+)(.)].*/\c[c[\2\1]/p
b
```
[Answer]
# c, 100
```
char *s="....      ....     ";main(i){for(i=0;;i=(i+9)%10)dprintf(2,"[%.10s]\r",s+i),usleep(3<<15);}
```
]