CASIO BASIC (CASIO fx-9750GIII), 56 bytes

Lbl A
Locate 1,1,"--:--
For 1→N To 300
Not (N Rmdr 150⟹Locate 1,1,"12:00
Next
Goto A

it may be a little off because CASIO BASIC doesn't have any timing implementation.

Japt, 27 25 bytes

OqU°g"12:00 --:--"¸500t@ß

Test it

OqU°g"..."¸500t@ß
Oq                    :Overwrite the current output with
  U                   :  First input variable (defaults to 0)
   °                  :  Postfix increment
    g                 :  Index into (0-based & modular)
     "..."            :    Literal string
          ¸           :    Split on spaces
           500t       :Set a timeout of 500ms
               @      :To run the following function
                ß     :  Recursive call with implicit argument U

The t method returns a JavaScript timeoutID, which gets passed to the g method as a second argument but, as that method expects, at most, 1 argument, it gets ignored.

tcl, 49

while 1 {lmap x 12:00\ --:-- {puts $x;after 500}}

Can be tried on http://tpcg.io/_IGMNM3

Thanks to people on tcl IRC channel for helping me shortening the original version.

05AB1E, 23 20 19 bytes

"12:00"…--:û[s=₄;.W

Try it online.

Explanation:

"12:00"            # Push string "12:00"
       …--:        # Push string "--:"
           û       # Palindromize it to "--:--"
[                  # Loop indefinitely:
 s                 #  Swap the two values on the stack
  =                #  Print the top with trailing newline (without popping)
   ₄;              #  Push 1000 halved: 500
     .W            #  Sleep that many ms

"12:00" could alternatively be Žmy3':: for the same byte-count.

05AB1E, 19 bytes

…--:ûŽmy3'::[=s₄;.W

Try it online! Outputs each string on a new line.

Noodel, 16 bytes

--:-- 12:00ḷçėḍh

Noodel is still very much a work in progress. Just trying to get my feet wet with a couple of challenges.

Try it:)

How It Works

--:--            # Creates the string literal "--:--" and places i into the front of the pipe.
                 # Space is a NOP command to separate the string literals.
      12:00      # Creates the string literal "12:00" and places it into the front of the pipe.
           ḷ     # Loop the following code unconditionally.
            ç    # Clear the screen and print a copy of what is in the pipe.
             ė   # Take what is in the front of the pipe and put it into the back.
              ḍh # Delay for half a second.

Here is a code snippet:)

<div id="noodel" code="--:-- 12:00ḷçėḍh" input="" cols="10" 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>

Python 3, 75 bytes

import time
x=['12:00','--:--']
for i in x:x+=[i];print(i);time.sleep(.5)

Dyalog APL, 35 31 30 bytes

Full program.

{⌽⍵⊣⎕←5↑⍵⊣⎕DL÷2}⍣≡'12:00--:--'

'12:00--:--' a string

{...}⍣≡ Repeatedly apply the below anonymous function until two successive results are identical (i.e. never)

 ÷2 reciprocal of two (one half)

 ⎕DL Delay that many seconds (returns elapsed time)

 ⊣ discard that in favor of

 ⍵ the argument

 5↑ take the first five characters

 ⎕← display with newline

 ⊣ discard that in favor of

 ⌽⍵ reverse argument (implicitly returned)

Stax, 22 20 bytes

å√Φ←mp═╠╗⌐fâêÇY)♀╗}%

Run and debug it

QBasic, 51 bytes

LOCATE 1
IF TIMER*2MOD 2THEN?"12:00"ELSE?"--:--
RUN

Try it at Archive.org (but note that it's an infinite loop, so there's no way to exit the program besides closing/refreshing your browser).

Displays both strings on the top line of the screen. If you're using actual QBasic rather than QB64, you'll notice that the program doesn't clear the screen first, so there may be other junk present as well. This issue can be fixed at a cost of 8 bytes: add CLS:DO: at the beginning of the program and change RUN to LOOP.

Explanation

Waiting for a fraction of a second is hard in QBasic, as other answers have mentioned, since the built-in SLEEP command only takes integers. However, TIMER (which represents the number of seconds since midnight) is a floating-point value. Whenever its fractional part is less than .5, we'll print --:--, and whenever its fractional part is greater than .5, we'll print 12:00. Conveniently, the MOD operator truncates to integer, so we can use TIMER * 2 MOD 2 and get values of 0 and 1.

This approach prints many, many times per second, but most of the time it's printing the same value over itself, so nothing changes.

Ungolfed and commented:

LOCATE 1                  ' Move the cursor to the top row
IF TIMER * 2 MOD 2 THEN   ' Alternates between 0 and 1 with a period of 1 second
  PRINT "12:00"
ELSE
  PRINT "--:--"
END IF
RUN                       ' Restart the program

bash, 58 56 45 41 bytes

New version 2022, (not very system friendly), but...

bash <(yes "read -t.5 -p"{--:--,12:00}\;)

or with newline: 45

bash <(yes "read -t.5 -p'
"{--:--,12:00}"';")

or with carrier return: 47

bash <(yes "read -t.5 -p$'\r"{--:--,12:00}"';")

saved 3 byte by suppressing -- after set as 1st arg is a number.

set 12:00 --:--;for((a=1;;a=3-a)){ echo ${!a};sleep .5;}

f()(echo $1;sleep .5);f 12:00;f --:--;exec $0

Then loosing 5 bytes because of zeppelin's comment.

This could not be tested on command line. As we involve $0, this must be written into a script to run.

Divert

With a little preparation, this could become nice (412 bytes):

set -- "         ▗▖         
▗▄▄▖▗▄▄▖ ▝▘ ▗▄▄▖▗▄▄▖
         ▗▖         
         ▝▘         " " ▟▌ ▟▀▜▖ ▗▖ ▗▛▙ ▗▛▙ 
 ▐▌  ▗▟▘ ▝▘ █▗▐▌█▗▐▌
 ▐▌ ▗▛▗▖ ▗▖ ▜▖▟▘▜▖▟▘
▝▀▀▘▀▀▀▘ ▝▘  ▀▘  ▀▘ "
r=`tput cup 0`
clear;for((a=1;;a=3-a)){ printf "$r${!a}";sleep .5;}

Or even same two lines but with:

set -- '                                            






      HM!          .o#HMMMMM#o.                 .o#MMMMH#\\         .d#MMMMH#\\
    _HMMi         ?MMH*"""`"MMMb               dMMH"""`*MMH,      dMMH"""`*MMH.
##HMMMMMi        |MMP"       9MML             ?MMP      `MMM.    dMM?      `MMM.
`""`"9MM|        dMM!        -MMR     HMH}   .MMM        |MM}   .MMH        |MM|
     |MM|         "`         JMMT     dHH}   |MM|         MMM   |MM|        -MMM
     |MM!                 .,HMM*             |MM|         MMM.  ]MM|         MMM
     |MMi              _o#MMH*"              |MM|         MMM   {MM|         MMM
     |MMi           .dHMM#""                 |MM|         MMM"  {MM|        .MMM
     |MMi         .HMM*"                     `MM6        ,MMR   |MM}        |MMF
     |MMi        ,MMP"                        9MM,       dMM|    HMM,       dMM"
     {MMi        MMM?\\o,\\\\\\\\\\\\\\\\,     q##+    `HMM\\    .dMM?     `HMH\\    .dMM?
     |MM|       :MMMMMMMMMMMMMMM[     HMMk     `*HMM##MMM#"       `*HMM##MMMP"
      "`          "     ` ` ` `                   """"`""            """"""    ' '






                                                                                
                                                                                
                                                                                
                                      MHM|                                      
                                      HHH|                                      
                                                                                
               ______.  ._______.            ________.  ._______.               
               MMMMMM:  {MMMMMMM|            &MMMMMMM:  |MMMMMMM[               
                                                                                
                                                                                
                                      ###|                                      
                                      MMM|                                      
                                                                               '

QBasic (QB64) 55 53 Bytes

A$="12:00
B$="--:--
DO
?A$
_DELAY .5
SWAP A$,B$
LOOP

Saved 2 bytes as newline appears to terminate the string definitions.

SWAP makes all the difference. For vanilla QBASIC replace _DELAY with SLEEP S where S is an integer in seconds, but then the frequency is wrong.

Postscript 225 214

For fun only! Don't send this to a real printer!!

/Courier findfont 9 scalefont setfont{usertime 500 mod 5 lt{newpath 9 9 moveto 1 setgray 99 setlinewidth 99 99 lineto stroke 0 setgray}if newpath 9 9 moveto usertime 999 mod 500 lt{(--:--)}{(12:00)}ifelse show}loop

Try it:

gs -c '/Courier findfont 9 scalefont setfont{usertime 500 mod 5 lt{newpath 9 9 moveto 1 setgray 99 setlinewidth 99 99 lineto stroke 0 setgray}if newpath 9 9 moveto usertime 999 mod 500 lt{(--:--)}{(12:00)}ifelse show}loop'

or

cat <<eops >/tmp/blinkingTwelve.ps
%!
/Courier findfont
9 scalefont
setfont
{
  usertime 500 mod 5 lt {
    newpath
    9 9 moveto
    1 setgray
    99 setlinewidth
    99 99 lineto
    stroke
    0 setgray
  } if
  newpath
  9 9 moveto
  usertime 999 mod 500 lt {
    (--:--)
  } {
    (12:00)
  } ifelse
  show
} loop
eops

then

gs /tmp/blinkingTwelve.ps
gv /tmp/blinkingTwelve.ps

But don't try to open this with more sophisticated viewer and care about desktop thumbnailer!

GNU AWK, (until version 5.0.1), 64 bytes

This piece of code prints the strings on a new line. Only works in GNU AWK up to version 5.0.1, while the time extension (module) was not obsolete.

@load"time";BEGIN{for(;;){sleep(.5);print++t%2?"12:00":"--:--"}}

Clearing the screen with clear command (80 bytes)

This example uses the clear command, not native to Awk.

@load"time";BEGIN{for(;;){sleep(.5);system("clear");print++t%2?"12:00":"--:--"}}

Clearing the screen with \33[H\33[2J\33[3J (85 bytes)

But don't despair if there is no command to clear the screen on your system. Just hard code it. \33 is the ASCII for Escape in octal.

@load"time";BEGIN{for(;;){sleep(.5);print"\33[H\33[2J\33[3J"(++t%2?"12:00":"--:--")}}

C (clang), 51 bytes

f(i){puts(i?"12:00":"--:--");usleep(500000);f(!i);}

Try it online!

C# (.NET Core), 138 131 127 bytes

class H{static int Main(){for(int n=1;;System.Threading.Thread.Sleep(500))System.Console.WriteLine((n^=1)>0?"--:--":"12:00");}}

Try it online!

Simple one-liner code.

C# (.NET Core), 127 bytes

class H{static int Main(){for(int n=1;;System.Threading.Thread.Sleep(500))System.Console.Write((n^=1)>0?"\r--:--":"\r12:00");}}

Try it online!

This code has same length with the code above, it does replace previous line.

-7 bytes by using for loops.
-4 bytes by using ternary operator.

Python 3, 78 bytes

import time;x=0
while 1:x=not x;print("12:00--:--"[x*5:x*5+5]);time.sleep(0.5)

Try it online!

Dart, 103 bytes

import'dart:io';f({i=1}){while(i>0){print(i++%2>0?"12:00":"--:--");sleep(Duration(milliseconds:500));}}

Try it online!

Sometimes I hate how verbose and strongly typed Dart has to be :D

Powershell, 46 45 bytes

-1 byte, thanks @AdmBorkBork

for(){('12:00','--:--')[$i++%2]
sleep -m 500}

LibreLogo, 100 bytes (Non-Competing)

Code:

ht point fontsize 99 repeat [ cs sleep 500 if repcount % 2 [ label '12:00' ] else [ label '--:--' ]]

Explanation:

ht                            ; Hide Turtle (Unnecessary... Added for visual clarity)
point                         ; Draw a point with size and color of the pen
fontsize 99                   ; Font Size = 99 pt (Unnecessary... Added for visual clarity)
repeat [                      ; Endless Loop
    cs                        ; Clear Screen
    sleep 500                 ; Wait for 500 ms
    if repcount % 2 [         ; If the Repetition Count is Even...
        label '12:00'         ; Draw '12:00'
    ]
    else [                    ; Otherwise...
        label '--:--'         ; Draw '--:--'
    ]
]

Result:

PKod, 26 bytes

PKod is an esoteric language that only has one accessible variable

Code:

l12=:o00yyl=-oo=:o=-ooyy<

Explanation:
l - if first char in code, print any NOP chars found
12 - two NOP chars to print
=: - set variable as :
00 - two more NOP chars
o - print variable's corresponding ascii char
y - wait 0.25 seconds
l - if not first char in code, clear the console
=-oo - set variable as - and print twice
< - go back to the start of the code

Vim, 32 keystrokes

qq:sl500m<CR>S12:00<Esc>:<UP><CR>S--:--<Esc>@qq@q

Excel VBA (Win, Excel 32 bit Only), 97 Bytes

In a module:

Because VBA's Application.Wait() method cannot handle input for time periods of less than one second, a declaration of the kernel32 sleep method is used for the 500 ms wait period.

Declare Sub Sleep Lib "kernel32" (ByVal s&)

Note: 64-bit versions of VBA (VB7) require a PtrSafe tag after the Declare tag, and changing the ByVal s& call to ByVal s as LongPtr.

In the vbe immediates window:

Do:DoEvents:?"12:00":Sleep 500:?"--:--":Sleep 500:Loop

Octave, 63 62 61 55 bytes

c='--:--00:21';while c=flip(c)disp(c(1:5));pause(.5)end

Saved two bytes thanks to Tom Carpenter! Using a single string instead of two strings in a cell array was shorter.

Explanation:

c='--:--00:21';  % A string where the 5 first characters are --:-- or 12:00 when reversed
while c=flip(c)  % A string is always considered true in Octave, so this will loop forever
                 % while flipping the order of the string each time
 disp(c(1:5)     % display the 5 first characters of the string c
 pause(.5)       % Pause 0.5 second
end              % End loop

A few bytes saved because Octave doesn't require a colon or semicolon between flip(c) and disp(), and between pause(.5) and end.

SmileBASIC, 35 bytes

WAIT 30?"12:00
WAIT 30?"--:--
EXEC.

WAIT times are in frames (1/60 second), and EXEC. restarts the program (equivilant to EXEC 0 which runs the code that's in slot 0)

Version that clears the screen and adds 6 bytes:

WAIT 30CLS?"12:00
WAIT 30CLS?"--:--
EXEC.

ForceLang, 79 bytes

def d datetime.wait 500
def w io.writeln
label 1
w "12:00"
d
w "--:--"
d
goto 1

And here's a version in 125 bytes that actually clears the screen each time and blinks:

set z string.char 8
def d datetime.wait 500
set z z+z+z+z+z
label 1
io.write "12:00"
d
io.write z+"--:--"
d
io.write z
goto 1

8th, 62 58 51 bytes

: p . cr .5 sleep ; : f "12:00" p "--:--" p recurse ;

When invoked, the word f will display blinking twelve according the "new line" format. This code leverages "tail-call elimination" implemented in 8th.

The following code (95 bytes long) will let word f display blinking twelve according the "replacing the former string" format:

: p 0 0 con:gotoxy con:print ; 
: f con:cls repeat "12:00" p .5 sleep "--:--" p .5 sleep again ;

Perl 6,  48 41  34 bytes

loop {print "\r",<--:-- 12:00>[$_=!$_];sleep .5}

loop {put <--:-- 12:00>[$_=!$_];sleep .5}

sleep .put/2 for |<12:00 --:-->xx*

*><>, 30 bytes

cn"00:"ooo5Sdo"--:--"ooooo5Sdo

Online test.

I feel this is much simpler and more different than redstarcoder's algorithm, and thus I posted it as separate.

Replaces output in-place.

Python2, 80 75 73 69 67 66 bytes

import time
n=0
while[time.sleep(.5)]:print"1-2-::0-0-"[n::2];n^=1

I noticed that my string magic got a little longer than picking the string from an array. Nevermind, figured it out.

Explanation:

• I set a counter n to 0, which will be toggled between 0 and 1.

• I loop endlessly with the loop while 1.

• I create a string 1-2-::0-0-, which contains the string 12:00 and --:-- interlapped.

  • Starting from the index 0 with a step of 2, we get: 12:00

  • Starting from the index 1 with a step of 2, we get: --:--

• I use n to make the repeated sequence 0, 1, 0, 1, 0... which will be the starting index of the string.

  • Using n^=1, in each loop, we get that sequence. ^ being the XOR-operator.
  • If n == 0 --> n^=1 results in 1
  • If n == 1 --> n^=1 results in 0
• I print the string, and sleep (.5 -> 0.5) seconds.

@FlipTack saved 4 bytes! --> Put the loop in one line.

@Rod saved 2 bytes! --> n+=1 to n^=1, thus n%2 to n.

@xnor saved a byte! --> while 1 --> while[time.sleep(.5)].

Windows PowerShell, 46 55 bytes

function a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}

Original Code:

a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}
^ this won't work on other PCs. No idea why.

Pushy, 22 bytes (non-competing)

`--:`wO`12:0`&["500oWF

This answer makes use of the two stacks, by flipping between them, printing the characters in turn:

`--:`    \ Push these characters to stack 1
 w       \ Mirror around center, yielding "--:--"
 O       \ On the second stack...
 `12:0`  \ Push these characters
 &       \ Duplicate the last (for :00)

 [        \ Infinitely:
  "       \   Print the current stack
  500oW   \   Wait 500 milliseconds
  F       \   Swap stacks
          \ (Implicit end loop)

The oW command is part of a set of experimental commands that postdate the challenge, making this answer non-competing.

Python 2, 92 bytes

import time
t=0
while 1:u=t%2;v='--'*u;w=1-u;print v+'12'*w+':'+v+'00'*w;t+=1;time.sleep(.5)

Try it online!

Explanation

import time                                   Import the time module
t=0                                           Set a counter, 't', to 0
while 1:                                      Trigger an infinite loop
    u = t%2                                   Let 'u' be the remainder of t/2. This will alternate between 0 and 1 
    w = 1 - u                                 Let 'w' be the opposite of u
    v = '--'*u                                Python lets the repetition of strings by multiplying them by an int. Here we are either mulitplying by 1 (no effect) or 0 (turns it to an empty string)
    print v + '12'*w + ':' + v + '00'*w       Concatonating 4 strings and printing them. We are using string multiplication again on the '12' and '00'
    t += 1                                    Increment the counter variable
    time.sleep(0.5)                           Wait half a second

Q/KDB+, 61 Bytes

s:("12:00";"--:--")
b:1b
.z.ts:{b::not b;show s[b]}
\t 500

Explanation:

s:("12:00";"--:--")

Assign the values we wish to show in a list.

b:1b

Assign a boolean variable to flip between 0 and 1 easily.

.z.ts:{b::not b;show s[b]}

This is a KDB+ function which is invoked in set intervals by the timer function (\t) http://code.kx.com/wiki/Reference/dotzdotts
This executes the code inside the curly braces when \t is set. Show the value in s and then flipping the value of b between 0 and 1.

\t 500

Effectively calls .z.ts every 500ms.

Clojure, 79 62 bytes

V2

-17 bytes by changing from an awful indexing loop to looping over an infinite list.

Creates an infinite list of "12:00" and "--:--" repeating over and over again, then uses doseq to constantly pull the next message, and print it.

(doseq[m(cycle["12:00""--:--"])](Thread/sleep 500)(println m))

V1

(loop[i 0](Thread/sleep 500)(println(["12:00""--:--"]i))(recur(if(= 0 i)1 0))))

I couldn't think of a good way to compact the "12:00" and "--:--" constants, so I had to just hard code them.

Ungolfed:

(loop [i 0] ; Track which sign we showed last
    (Thread/sleep 500)
    (println (["12:00" "--:--"] i)) ; Index the vector to get the string to print
    (recur (if (= 0 i)1 0))) ; Swap the index, and loop again

QuickBASIC, 167 bites (yummy)

a%=VAL(RIGHT$(STR$(TIMER*100),2))
b%=a%+50
IF b%>99THEN b%=b%-99
DO
c%=VAL(RIGHT$(STR$(TIMER*100),2))
IF c%=a% THEN PRINT"--:--"
IF c%=b% THEN PRINT"12:00"
LOOP

I was never going to win anyways. QB doesn't have a floor(), and also doesn't have a function to sleep for x milliseconds. Therefore, this works by grabbing the floating point portion of the TIMER (returns seconds elapsed since midnight, plus a fraction of the current second expressed as a two-digit decimal). We then add a loop-around "50 units" to it to determine when the phase should switch from "--:--" to "12:00", and use the original TIMER decimal for the switch from "12:00" to "--:--".

Finally, even running this complied in QB4.5, in DOSBox on a rather powerful machine will skip beats. That's because QB really isn't fast enough to perform the DO-LOOP and evaluations inside of the MS we're doing the comparison in. Would need a box from the FUTURE!

Anyway, I now look 100, and I made every American University student happy since they probably have an answer for their Comp Sci class -- since they're still teaching this...

HTML/CSS, 131 108 106 101 + 18 17 = 149 126 125 123 118 bytes

a{background:#FFF;margin:-5ch;animation:a 1s steps(2,start)infinite}@keyframes a{to{visibility:hidden

<tt>--:--<a>12:00

Edit: Saved 23 bytes thanks to @insertusernamehere. Saved 1 byte by switching from <pre> to <tt>. Saved 2 bytes thanks to @darrylyeo. Saved 5 bytes thanks to @DBS.

Lua, 94 bytes

Unfortunately Lua has no built-in sleep function, so a loop is necessary.

x=1 z=os.clock while 1 do x=-x print(x<0 and"12:00"or"--:--") y=z()+.5 repeat until z()>y end

As a bonus, here's a Windows only one which is 109 bytes and which clears the screen each time:

x=1 z=os.clock while 1 do x=-x print(x<0 and"12:00"or"--:--") y=z()+.5 repeat until z()>y os.execute"cls"end

REXX, 60, 54 bytes

d.='--:--'
d.1='12:00'
a=1
do b=0
  sleep(.5)
  a=\a
  say d.a
  end

(Indented for readability)

Edit: Turns out that the most naïve solution is even shorter:

do b=0
say '12:00'
sleep(.5)
say '--:--'
sleep(.5)
end

Tested with Regina REXX interpreter; some older implementations may not have the Delay function at all, or it may only support whole seconds.

R 69 65 61 bytes

y=1;while(1){cat('\r',c('12:00','--:--')[y]);Sys.sleep(.5);y=(y==1)+1}

while(1){cat('\r12:00');Sys.sleep(.5);cat('\r--:--');Sys.sleep(.5)}

f=Sys.sleep;while(1){cat('\r12:00');f(.5);cat('\r--:--');f(.5)}

First time using the f = blah_function() trick, and it saved a few bytes. Used \r to replace existing string.

Fairly simple implementation:

f = Sys.sleep;      #store function for repeated usage
while(1){
    cat('\r12:00'); #print 12
    f(.5);          #sleep
    cat('\r--:--'); #print --
    f(.5)           #sleep again
}

PHP, 48 bytes

for(;;usleep(5e5))echo($n^=1)?"
12:00":"
--:--";

Run with -nr.

Replace instead of multiple lines with \r instead of \n (+2 bytes):

for(;;usleep(5e5))echo($n^=1)?"\r12:00":"\r--:--";

HTML/CSS (Chrome only), 80 + 4 = 84 bytes

tt:after{content:"--:--";animation:a 1s infinite}@keyframes a{to{content:"12:00"

<tt>

Edit: The "content" attribute is not animatable by the CSS specification, but is on Chrome desktop browser.

dc (bash), 37 bytes

[12:00][--:--][[rp!sleep .5]xlax]dsax

This works by pushing the two strings "12:00" and "--:--" on the stack and then repeatedly swapping the values, printing the item at the top of the stack, and sleeping half a second.

To run this, you can save it in a file and then type

dc filename

or you can run it directly from the bash command line by typing

dc <<<'[12:00][--:--][[rp!sleep .5]xlax]dsax'

V, 31 30 27 25 24 bytes

Saved 5 bytes thanks to @nmjcman101 by swapping the order of 12:00 and --:-- so that k can be removed any by removing ò so that it could be added implicitly at the end

Saved 1 byte thanks to @DJMcMayhem by putting both 12:00 and --:-- in one line

i12:00--:--<ESC>bDòVp:sl500m

Old Solution:

i12:00<ESC>ò:sl500m
Óä/-
:sl500m
uò

<ESC> is 0x1b

Hexdump:

00000000: 6931 323a 3030 2d2d 3a2d 2d1b 6244 f256  i12:00--:--.bD.V
00000010: 703a 736c 3530 306d                      p:sl500m

Explanation

i12:00--:--<ESC>   inserts 12:00\n--:--
bD                 go to the beginning of --:-- and delete it
ò                  recursively do:
 Vp                 select line and paste (effectively doing a replace)
 :sl500m            sleep for 500 milliseconds
                   the last ò is added implicitly at the end

Gif (outdated)

Note: I have highlighting turned on

C 79 Bytes

f(){while(1){printf("\n12:00");usleep(500000);printf("\n--:--");usleep(500000);}}

so the main would look like int main(){ f(); return 0;}

HTML + CSS, 147, 148 142 Bytes

*{font-family:Courier;left 0;background-color:white;position:absolute}@keyframes d{0%,49%{left:0}50%,to{left:-10em}}a{animation:d 1s infinite}

12:00<a>--:--

Explanation:

Basically, this uses two HTML elements: A text node containing 12:00 and an <a> tag containing --:--.

The selector in the CSS applies to both elements, giving both absolute positioning 0 to the left. This allows both elements to overlap. Then, I gave both elements a monospace font, making each take up equal widths. Finally, I set the background color to white, making sure that the <a> tag hides the text it overlaps.

Then, I use an animation to move the <a> tag offscreen every .5 seconds. To do this, the animation lasts one second, and shows the tag for the first 49%, then hides it for the last 50%.

Oh - finally, Courier is shorter than monospace, saving 3 bytes, but it might not work in all browsers/operating systems.

Update: +1 Byte

Turns out that Monaco isn't on everyone's computer. changed to using Courier instead at the expense of a byte.

Update: -6 Bytes

Forgot to remove a bit of whitespace. Oops.

Non minified code:

* {
  position: absolute;
  left: 0;
  font-family: Courier;
  background-color: white;
}
@keyframes d {
  0%, 49% {
    left: 0
  }
  50%, to {
    left: -10em
  }
}
a{animation: d 1s infinite}

12:00<a>--:--

Scala, 100 bytes

object C extends App{var p=1>2;while(2>1){p= !p;println(if(p)"12:00"else"--:--");Thread.sleep(500)}}

GameMaker Language, 47 bytes

a="12:00"if 9<c mod 20a="--:--"draw_text(0,0,a)

(Assuming a room speed of 20 fps)

Jelly, 20 bytes

.“12:00“--:--”ṄœS¥€ß

How it works

.“12:00“--:--”ṄœS¥€ß  Main link. No arguments.

.                     Set the return value to 0.5.
 “12:00“--:--”        Yield ["12:00", "--:--"].
                 ¥    Combine the two links to the left into a dyadic chain.
              Ṅ       Print the left argument.
               œS     Sleep as many seconds as the right argument specifies.
                  €   Map the created dyadic chain over the string array, with
                      right argument equal to the return value, i.e., 0.5.
                   ß  Recursive call the main link.

C, 77 bytes

#import<windows.h>
i;f(){for(;;i^=1)Sleep(83*printf(i?"\r--:--":"\r12:00"));}

Shell and pv, 26 bytes

This use yes standard tool and pv Shell pipeline element to meter data passing through

yes '12:00
--:--'|pv -qlL2

Javascript (in browser), 174 160 159 122 112 111 109 107 66 (91) bytes

I've taked of pre because using monotyped font is not part of requirement, so my new count is 66. Some chars are added to use monospaced font but as this is not needed, I won't count this 25 more chars.

Thanks to ETHproductions for saving 14 bytes,

to Kritixi Lithos for saving 1 byte,

to manatwork for saving 1 3 byte,

to Christoph for saving two more bytes and

to myself for saving 37 bytes by using [..][b^=1] instead of setTimeout... and 10 more by replacing function(){..} by double-quotes...

setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500)

body{font-family:Courier}

... worse:

From 66 to something more...

... but for fun, in the spirit of a blinking display:

SVG="http://www.w3.org/2000/svg";XLNK="http://www.w3.org/1999/xlink";
s=["1200","----"];p=0;function d(n){for(i=n.length;i>0;i--) {
  document.getElementById('n'+i).setAttribute('class','n'+n[i-1])}
  document.getElementById('sz').setAttribute('class','n'+n[0])}
setInterval("p=1-p;d(s[p])",500);

#svg2 { --c: #FF6;stroke:#432;stroke-width:12;stroke-linecap:round;stroke-linejoin:round; stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none; } path.b { fill:#543;stroke:none; } .blue     { --c: #68F; } .green    { --c: #6F8; } .red      { --c: #F88; } .dec rect  { stroke: var(--c); } .n1 #B { stroke: var(--c); }  .n1 #C { stroke: var(--c); } .n2 #A { stroke: var(--c); }  .n2 #B { stroke: var(--c); } .n2 #D { stroke: var(--c); }  .n2 #E { stroke: var(--c); } .n2 #G { stroke: var(--c); }  .n3 #A { stroke: var(--c); } .n3 #B { stroke: var(--c); }  .n3 #C { stroke: var(--c); } .n3 #D { stroke: var(--c); }  .n3 #G { stroke: var(--c); } .n4 #B { stroke: var(--c); }  .n4 #C { stroke: var(--c); } .n4 #F { stroke: var(--c); }  .n4 #G { stroke: var(--c); } .n5 #A { stroke: var(--c); }  .n5 #C { stroke: var(--c); } .n5 #D { stroke: var(--c); }  .n5 #F { stroke: var(--c); } .n5 #G { stroke: var(--c); } .n6 #A { stroke: var(--c); }  .n6 #C { stroke: var(--c); } .n6 #D { stroke: var(--c); }  .n6 #E { stroke: var(--c); } .n6 #F { stroke: var(--c); }  .n6 #G { stroke: var(--c); } .n7 #A { stroke: var(--c); }  .n7 #B { stroke: var(--c); } .n7 #C { stroke: var(--c); } .n8 #A { stroke: var(--c); }  .n8 #B { stroke: var(--c); } .n8 #C { stroke: var(--c); }  .n8 #D { stroke: var(--c); } .n8 #E { stroke: var(--c); }  .n8 #F { stroke: var(--c); } .n8 #G { stroke: var(--c); } .n9 #A { stroke: var(--c); }  .n9 #B { stroke: var(--c); } .n9 #C { stroke: var(--c); }  .n9 #D { stroke: var(--c); } .n9 #F { stroke: var(--c); }  .n9 #G { stroke: var(--c); } .n0 #A { stroke: var(--c); }  .n0 #B { stroke: var(--c); } .n0 #C { stroke: var(--c); }  .n0 #D { stroke: var(--c); } .n0 #E { stroke: var(--c); }  .n0 #F { stroke: var(--c); } .n11 #B { stroke: var(--c); } .n11 #C { stroke: var(--c); } .n11 #E { stroke: var(--c); } .n11 #F { stroke: var(--c); } .nA #A { stroke: var(--c); }  .nA #B { stroke: var(--c); } .nA #C { stroke: var(--c); }  .nA #E { stroke: var(--c); } .nA #F { stroke: var(--c); }  .nA #G { stroke: var(--c); } .nB #C { stroke: var(--c); }  .nB #D { stroke: var(--c); } .nB #E { stroke: var(--c); }  .nB #F { stroke: var(--c); } .nB #G { stroke: var(--c); } .nC #A { stroke: var(--c); }  .nC #D { stroke: var(--c); } .nC #E { stroke: var(--c); }  .nC #F { stroke: var(--c); } .nD #B { stroke: var(--c); }  .nD #C { stroke: var(--c); } .nD #D { stroke: var(--c); }  .nD #E { stroke: var(--c); } .nD #G { stroke: var(--c); } .nE #A { stroke: var(--c); }  .nE #D { stroke: var(--c); } .nE #E { stroke: var(--c); }  .nE #F { stroke: var(--c); } .nE #G { stroke: var(--c); } .nF #A { stroke: var(--c); }  .nF #E { stroke: var(--c); } .nF #F { stroke: var(--c); }  .nF #G { stroke: var(--c); } .nR #E { stroke: var(--c); }  .nR #G { stroke: var(--c); } .nO #C { stroke: var(--c); }  .nO #D { stroke: var(--c); } .nO #E { stroke: var(--c); }  .nO #G { stroke: var(--c); } .n- #G { stroke: var(--c); }  .n1 #y { stroke: var(--c); } .n1 #z { stroke: var(--c); }

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="100%" height="100%" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 645 230" id="svg2"> <defs id="dfs4"><g id="n"><path d="M 15,5 155,5 145,225 5,225 z" class="b"/> <path id="A" d="M 45,15 125, 15"/><path id="B" d="M 135,25 125,105"/><path id="C" d="M 125,125 115,205"/><path id="D" d="M 25,215 105,215"/><path id="E" d="M 25,125 15,205"/><path id="F" d="M 35,25 25,105"/><path id="G" d="M 35,115 115,115"/><rect id="P" width="5" height="5" ry="2.5" x="130" y="205"/></g><g id="s"><path d="M 10,5 35,5 25,225 0,225 z" id="a" class="b"/><rect id="y" width="5" height="5" ry="2.5" x="13.5" y="145"/><rect id="z" width="5" x="17" height="5" ry="2.5" y="75"/></g></defs><use id="n1" xlink:href="#n" /><use id="n2" xlink:href="#n" transform="translate(150,0)" /><use xlink:href="#s" id="sz" transform="translate(305,0)"/><use id="n3" transform="translate(335,0)" xlink:href="#n" /><use id="n4" xlink:href="#n" transform="translate(485,0)" />
</svg>

GNU sed, 39 bytes

EDITS:

• Swapped sleep and i12:00 (to make source code look a bit nicer)

Golfed

s/^/sleep .5/
h
i12:00
e
i--:--
x
e
G
D

Explained

s/^/sleep .5/   #Put 'sleep .5' to the pattern space
h               #Copy pattern space to hold space
i12:00          #Print "12:00" (insert before a line) 
e               #Execute command that is found in pattern space
i--:--          #Print "--:--"
x               #Exchange the contents of the hold and pattern spaces
e               #Execute command that is found in pattern space

G               #Append a newline to the contents of the pattern 
                #space, and then append the contents of the hold
                #space to that of the pattern space.

D               #Delete text in the pattern space up to the 
                #first newline, and restart cycle with the 
                #resultant pattern space, without reading a new 
                #line of input.
                

Try It Online !

Java, 152 151 bytes (Thanks @AlexRacer)

public class c{public static void main(String[] a)throws Exception{int i=1;while(i>0){System.out.println(i++%2<1?"--:--":"12:00");Thread.sleep(500);}}}

Try it here! * (this compiler prints only once a second, couldn't find a better one)

under construction, I missed the 1 second delay

awk, 3534 bytes (+11 for 12:00 --:--)

{for(;++i;i=i%2)print$(i)"\033[A"}

for loop alternates i's value between 1 and 2. echo feeds the values to the program into fields $1and $2, we then print $(i). Try it:

$ echo 12:00 --:-- | awk '{for(;++i;i=i%2)print$(i)"\033[A"}'

Edit: Thanks for the ANSI tip to @F.Hauri.

Python 2, 68 Bytes

import time
while 1:
 for i in'12:00','--:--':print i;time.sleep(.5)

Processing, 69 bytes

void draw(){println("12:00");delay(500);println("--:--");delay(500);}

Arduino CC, 79 bytes

void loop(){Serial.print("12:00");delay(500);Serial.print("--:--");delay(500);}

I have no experience with C/C++, so I don't really know how I can golf this.

PHP, 51 50 47

for(;;usleep(5e5))echo$i++%2?"--:--
":"12:00
";

1 byte saved due to manatwork and another 3 saved by insertusernamehere. Thanks!

Javascript, 57 55

setInterval('console.log(++i%2?"12:00":"--:--")',i=500)

2 bytes saved thanks to ETHproductions

JavaScript, 59 bytes

y=1;setInterval('console.log(["12:00","--:--"][y^=1])',500)

Explanation

setInterval('...',500) sets an interval to execute code in the string every 500 milliseconds, or 1/2 a second.

y=1 sets a variable, y, to 1 initially. That way, the first thing that is printed is 12:00 because y is used to access the array.

console.log(...) logs whatever to the console, in this either 12:00 or --:--.

["12:00","--:--"][y^=1] creates an array with strings containing both states. Then, y is used to access one of elements. Finally, ^=, or XOR compound operator does y = y ^ 1. This just inverts the bit because 1 ^ 1 is 0, and 0 ^ 1 is 1, similar to what @TuukkaX did. This way, the string logged alternates between the two elements in the array and thus creates the blinking effect.

S.I.L.O.S, 61 bytes

lbla
def p printLine
p 12:00
wait 500
p --:--
wait 500
GOTO a

Try it online!

Unfortunately TIO will just do nothing forever, as it waits until execution to print this. But, if you are eager to test, you can use the GitHub link.

ruby, 47 42 bytes

No ruby answer yet, so here is my first try:

%w{12:00 --:--}.cycle{|a|puts a;sleep 0.5}

*><>, 43 42 bytes

<v":1200----"
S>@5dov>~r@@}r5
1&}o:&<^!?:-

Try it here!

I feel like I should be able to make this shorter, I have a couple ideas to try ... Basically this makes a stack of :1200----. It isolates the : and flips the stack, inserting the : in the middle of either ---- or 1200 (depending on whichever is at the end of the stack).

I should also note that the only *><> instruction this uses is S (sleep), otherwise this is a proper ><> program.

Update: Saved 1 byte by shifting the : to the right instead of protecting it with a register.

Explanation

Initialisation

<v":1200----"

Here we build the stack we'll be using for the life of the program.

<              move the IP left
  ":1200----"  push ":1200----" to the stack
 v             move the IP down into "output time"

Output time

 >@5dov
1&}o:&<^!?:-

This is the section where the time is actually outputted. First 5 is pushed to the stack so the loop below knows to run 5 times.

Initialisation:

 >@5dov

 >       move the IP right
  @      move the ":" back two spaces in the stack
   5     push 5 to the stack (let's call this `i`)
    do   output carriage return
      v  move IP down into "loop"

Loop:

1&}o:&<^!?:-

      <       move the IP left
     &        place i onto the register
  }o:         output a character and shift the stack left
 &            place i back onto the stack
1          -  decrement i by 1
       ^!?:   if i == 0, exit to "recover and swap"

Recover and swap

S      >~r@@}r5

Here we recover the : from the position it results in after the output, and we end up with a reversed stack. This actually exits into "output time" nicely, causing an infinite loop.

       >         move the IP right
        ~        remove trailing i from stack
         r@@     reverse the stack and move ":" to the front
            }r   reverse the stack again, keeping ":" on the front
S             5  sleep for 500ms

45 byte solution

<v[5"12:00"1
d/S5
o/!?l
v>]?v
 00.>0"--:--"5[

Try it here!

This one is also basically a ><> program.

I really thought it'd be able to save some bytes with this approach. This quite simply outputs 12:00, then --:--. I save bytes by reusing the output routine o/!?l (I even reuse that mirror as both entry and exit). I utilise multiple stacks to store the state (has output 12 or --), and select which state I should output with v>]?v.

^{Explanations coming soon! (1/2)}

Mathematica, 38 bytes

Dynamic@If[Clock[]>.5,"12:00","--:--"]

Explanation

Clock[]

Outputs a clock variable that cycles continuously from 0 to 1 every second.

If[Clock[]>.5,"12:00","--:--"]

If the clock variable is greater than .5, output "12:00." If not, output "--:--".

Dynamic@ ...

Make the program dynamic (constantly updating)

Haskell, 79 bytes

import System.Posix.Unistd
m=(>>usleep 500000).putStrLn
g=m"12:00">>m"--:--">>g

m is a helper function that waits half a second before printing its argument. The main function g calls m "12:00", then m "--:--" and then itself again.

QBIC, 37 33 bytes

{sleep 01?@12:00`┘sleep 01?@--:--

QBasic unfortunately can only sleep for whole seconds. I'll see about devising a method to allow for more flexibility soon. I've input 1 as 01 to simulate .5.

Explanation:

{         Starts DO loop
sleep 01  Sleeps for 1 second
?@12:00`  Creates A$, sets value to "12:00" and prints A$
┘         Newline: a string literal doesn't break the line, so we need a newline to 
          control the compiled QBasic syntax
          <Rinse and repeat for "--:--">
          <DO-LOOP implicitly closed by QBIC>

In older builds of QBIC, $ and (space) were reserved characters. Calling a QBasic function that needed spaces (like sleep x) or $ (left$(..)) required a code literal:

'QBASIC CODE`

Code in a code literal block is passed directly to QBasic without being parsed by QBIC. By offloading functions from those symbols ($ became ', and newlines are now ┘ (alt-217) instead of ) the symbols are no longer seen by QBIC as special chars and simply passed on. The same is effectively true for the lowercase alphabet: it's used to represent numeric variables in both QBIC and QBasic and are left unchanged. Using QBasic functionality that is not implemented in QBIC (like SLEEP) is therefor simply a matter of not using QBIC reserved chars. This is made easier with the recent changes in the command symbols.

Jelly, 22 bytes

®‘©ị“12:00“--:--”ṄœS.ß

Doesn't work on TIO. Getting Jelly to run on Android with QPython3 was also a fun experience.

Explanation

®‘©ị“12:00“--:--”ṄœS.ß    Main link. No arguments. 
®                         Read the register. Initially 0.
 ‘                        Increment. 
  ©                       Save to the register.
   ị                      Get the n'th (wrapping) item of...
    “12:00“--:--”         ["12:00", "--:--"]
                 Ṅ        Print the string and a newline. 
                  œS      Sleep for...
                    .     ...0.5 seconds. (. is an alias for 0.5)
                     ß    Call this link again. 

Python 2, 88 85 73 71 bytes

import time
c="--:--00:21"
while 1:print c[:5];c=c[::-1];time.sleep(.5)

Try it here!

By borrowing Stewie Griffin's idea of flipping the list, the program was made possible. Ungolfed version with explanation:

import time                      # Import time module
c = "--:--00:21"                 # String with two values
while 1:                         # Infinite Loop
    print c[::5]                 # Print the first 5 chars in string
    c = c[::-1]                  # Flip the string
    time.sleep(.5)               # Wait 0.5 seconds

Thanks @FlipTack for saving 14 bytes!

JavaScript, 77 76 72 bytes

setInterval('l=console.log,l("12:00"),setTimeout("l(`--:--`)",‌​500)',1e3)

Thanks to Kritixi Lithos for 1 byte and L. Serne for 4 bytes!

Pyth, 23 bytes

#?=!Z"12:00""--:--".d.5

In pseudocode:

                Z = 0
#               while 1:
 ?=!Z               if ( Z = not Z ):
     "12:00"            print("12:00")
                    else:
     "--:--"            print("--:--")
 .d.5               sleep(0.5)

Uses preinitialized variable Z as the flip-flop, and inverts its state every time if tries to check the condition.

Perl, 49 bytes

{select$,,$,,$,,0.5;say$|--?"12:00":"--:--";redo}

Perl's sleep can't sleep for duration bellow 1 sec, hence the use of select undef, undef, undef, .5 (golfed by replacing undef with $,) to sleep .5 second.
Other interesting thing: $| can only hold 0 or 1. So $|-- just toggles its value, from 0 to 1.
And finally, {... ;redo} acts like an infinite loop.