diff --git a/src/CurrentCallVC.mm b/src/CurrentCallVC.mm
index 078e617..7971a6f 100644
--- a/src/CurrentCallVC.mm
+++ b/src/CurrentCallVC.mm
@@ -42,6 +42,7 @@
 #import <video/renderer.h>
 #import <media/text.h>
 
+#import "views/ITProgressIndicator.h"
 #import "views/CallView.h"
 
 @interface RendererConnectionsHolder : NSObject
@@ -67,6 +68,7 @@
 @property (unsafe_unretained) IBOutlet NSButton *muteAudioButton;
 @property (unsafe_unretained) IBOutlet NSButton *muteVideoButton;
 
+@property (unsafe_unretained) IBOutlet ITProgressIndicator *loadingIndicator;
 
 @property (unsafe_unretained) IBOutlet NSTextField *timeSpentLabel;
 @property (unsafe_unretained) IBOutlet NSView *controlsPanel;
@@ -91,7 +93,7 @@
 @synthesize personLabel, actionHash, stateLabel, holdOnOffButton, hangUpButton,
             recordOnOffButton, pickUpButton, chatButton, timeSpentLabel,
             muteVideoButton, muteAudioButton, controlsPanel, videoView,
-            videoLayer, previewLayer, previewView, splitView;
+            videoLayer, previewLayer, previewView, splitView, loadingIndicator;
 
 @synthesize previewHolder;
 @synthesize videoHolder;
@@ -130,53 +132,42 @@
     [timeSpentLabel setStringValue:callIdx.data((int)Call::Role::Length).toString().toNSString()];
 
     Call::State state = callIdx.data((int)Call::Role::State).value<Call::State>();
-
+    [loadingIndicator setHidden:YES];
+    [stateLabel setStringValue:callIdx.data((int)Call::Role::HumanStateName).toString().toNSString()];
     switch (state) {
         case Call::State::DIALING:
-            [stateLabel setStringValue:@"Dialing"];
+            [loadingIndicator setHidden:NO];
             break;
         case Call::State::NEW:
-            [stateLabel setStringValue:@"New"];
             break;
         case Call::State::INITIALIZATION:
-            [stateLabel setStringValue:@"Initializing"];
             [videoView setShouldAcceptInteractions:NO];
+            [loadingIndicator setHidden:NO];
+            break;
+        case Call::State::CONNECTED:
+            [videoView setShouldAcceptInteractions:NO];
+            [loadingIndicator setHidden:NO];
             break;
         case Call::State::RINGING:
-            [stateLabel setStringValue:@"Ringing"];
             [videoView setShouldAcceptInteractions:NO];
             break;
         case Call::State::CURRENT:
-            [stateLabel setStringValue:@"Current"];
             [videoView setShouldAcceptInteractions:YES];
             break;
         case Call::State::HOLD:
-            [stateLabel setStringValue:@"On Hold"];
             [videoView setShouldAcceptInteractions:NO];
             break;
         case Call::State::BUSY:
-            [stateLabel setStringValue:@"Busy"];
             [videoView setShouldAcceptInteractions:NO];
             break;
         case Call::State::OVER:
-            [stateLabel setStringValue:@"Finished"];
             [videoView setShouldAcceptInteractions:NO];
             if(videoView.isInFullScreenMode)
                 [videoView exitFullScreenModeWithOptions:nil];
             break;
-        case Call::State::ABORTED:
-            [stateLabel setStringValue:@"Aborted"];
-            break;
         case Call::State::FAILURE:
-            [stateLabel setStringValue:@"Failure"];
             [videoView setShouldAcceptInteractions:NO];
             break;
-        case Call::State::INCOMING:
-            [stateLabel setStringValue:@"Incoming"];
-            break;
-        default:
-            [stateLabel setStringValue:@""];
-            break;
     }
 
 }
@@ -221,6 +212,12 @@
     previewHolder = [[RendererConnectionsHolder alloc] init];
     videoHolder = [[RendererConnectionsHolder alloc] init];
 
+    [loadingIndicator setColor:[NSColor whiteColor]];
+    [loadingIndicator setNumberOfLines:100];
+    [loadingIndicator setWidthOfLine:2];
+    [loadingIndicator setLengthOfLine:2];
+    [loadingIndicator setInnerMargin:30];
+
     [self.videoView setFullScreenDelegate:self];
 
     [self connect];
diff --git a/src/views/ITProgressIndicator.h b/src/views/ITProgressIndicator.h
new file mode 100644
index 0000000..59ee8ea
--- /dev/null
+++ b/src/views/ITProgressIndicator.h
@@ -0,0 +1,88 @@
+//Copyright 2013-2015 Ilija Tovilo
+//
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+
+
+#import <Cocoa/Cocoa.h>
+#import <QuartzCore/QuartzCore.h>
+
+//
+// !!!IMPORTANT!!! - Embedd ITProgressIndicator in a layer-backed view to avoid side-effects!
+//
+
+/**
+ *  @class ITProgressIndicator
+ *
+ *  A replacement for `NSProgressIndicator`.
+ *  It's a highly customizable control, driven by Core Animation, which makes it much more performant.
+ *
+ *  So basically, it's awesome.
+ *
+ */
+@interface ITProgressIndicator : NSView
+
+#pragma mark - Methods
+
+/**
+ *  Override this method to achieve a custom animation
+ *
+ *  @return CAKeyframeAnimation - animation which will be put on the progress indicator layer
+ */
+- (CAKeyframeAnimation *)keyFrameAnimationForCurrentPreferences;
+
+#pragma mark - Properties
+
+
+/// @property isIndeterminate - Indicates if the view will show the progress, or just spin
+@property (nonatomic, setter = setIndeterminate:) BOOL isIndeterminate;
+
+
+/// @property progress - The amount that should be shown when `isIndeterminate` is set to `YES`
+@property (nonatomic) CGFloat progress;
+
+
+/// @property animates - Indicates if the view is animating
+@property (nonatomic) BOOL animates;
+
+
+/// @property hideWhenStopped - Indicates if the view will be hidden if it's stopped
+@property (nonatomic) BOOL hideWhenStopped;
+
+
+/// @property lengthOfLine - The length of a single line
+@property (nonatomic) CGFloat lengthOfLine;
+
+
+/// @property widthOfLine - The width of a single line
+@property (nonatomic) CGFloat widthOfLine;
+
+
+/// @property numberOfLines - The number of lines of the indicator
+@property (nonatomic) NSUInteger numberOfLines;
+
+
+/// @property innerMargin - The distance of the lines from the middle
+@property (nonatomic) CGFloat innerMargin;
+
+
+/// @property animationDuration - Duration of a single rotation
+@property (nonatomic) CGFloat animationDuration;
+
+
+/// @property gradualAnimation - Defines if the animation is smooth or gradual
+@property (nonatomic) BOOL steppedAnimation;
+
+/// @property color - The color of the progress indicator
+@property (nonatomic, strong) NSColor *color;
+
+@end
diff --git a/src/views/ITProgressIndicator.mm b/src/views/ITProgressIndicator.mm
new file mode 100644
index 0000000..189ea79
--- /dev/null
+++ b/src/views/ITProgressIndicator.mm
@@ -0,0 +1,349 @@
+//Copyright 2013-2015 Ilija Tovilo
+//
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+
+#if !__has_feature(objc_arc)
+#error ARC needs to be enabled!
+#endif
+
+
+#import "ITProgressIndicator.h"
+
+
+#pragma mark - Consts
+#define kITSpinAnimationKey @"spinAnimation"
+#define kITProgressPropertyKey @"progress"
+
+
+// ----------------------------------------------------------------------------------------
+#pragma mark - NSBezierPath+IT_Geometry
+// ----------------------------------------------------------------------------------------
+
+@interface NSBezierPath (IT_Geometry)
+
+- (NSBezierPath*)it_rotatedBezierPath:(float) angle;
+- (NSBezierPath*)it_rotatedBezierPath:(float) angle aboutPoint:(NSPoint)point;
+
+@end
+
+@implementation NSBezierPath (IT_Geometry)
+
+- (NSBezierPath *)it_rotatedBezierPath:(float)angle {
+	return [self it_rotatedBezierPath:angle aboutPoint:NSMakePoint(NSMidX(self.bounds), NSMidY(self.bounds))];
+}
+
+- (NSBezierPath*)it_rotatedBezierPath:(float)angle aboutPoint:(NSPoint)point {
+	if(angle == 0.0) return self;
+	else
+	{
+		NSBezierPath* copy = [self copy];
+		NSAffineTransform *xfm = [self it_rotationTransformWithAngle:angle aboutPoint:point];
+		[copy transformUsingAffineTransform:xfm];
+
+		return copy;
+	}
+}
+
+- (NSAffineTransform *)it_rotationTransformWithAngle:(const float)angle aboutPoint:(const NSPoint)aboutPoint {
+	NSAffineTransform *xfm = [NSAffineTransform transform];
+	[xfm translateXBy:aboutPoint.x yBy:aboutPoint.y];
+	[xfm rotateByRadians:angle];
+	[xfm translateXBy:-aboutPoint.x yBy:-aboutPoint.y];
+
+	return xfm;
+}
+
+@end
+
+
+
+
+// ----------------------------------------------------------------------------------------
+#pragma mark - ITProgressIndicator
+// ----------------------------------------------------------------------------------------
+
+#pragma mark - Private Interface
+
+@interface ITProgressIndicator ()
+@property (nonatomic, strong, readonly) CALayer *rootLayer;
+@property (nonatomic, strong, readonly) CALayer *progressIndicatorLayer;
+@end
+
+
+#pragma mark - Implementation
+
+@implementation ITProgressIndicator
+@synthesize progressIndicatorLayer = _progressIndicatorLayer;
+
+
+#pragma mark - Init
+
+- (id)initWithCoder:(NSCoder *)coder
+{
+    self = [super initWithCoder:coder];
+    if (self) {
+        [self initLayers];
+    }
+    return self;
+}
+
+- (id)initWithFrame:(NSRect)frame
+{
+    self = [super initWithFrame:frame];
+    if (self) {
+        [self initLayers];
+    }
+    return self;
+}
+
+- (void)initLayers {
+    // Setting initial values
+    self.color = [NSColor blackColor];
+    self.innerMargin = 4;
+	self.widthOfLine = 3;
+    self.lengthOfLine = 6;
+    self.numberOfLines = 8;
+    self.animationDuration = 0.6;
+    self.isIndeterminate = YES;
+    self.steppedAnimation = YES;
+    self.hideWhenStopped = YES;
+    self.animates = YES;
+
+    // Init layers
+    _rootLayer = [CALayer layer];
+    self.layer = _rootLayer;
+    [self setWantsLayer:YES];
+    self.progressIndicatorLayer.frame = _rootLayer.bounds;
+    [_rootLayer addSublayer:self.progressIndicatorLayer];
+
+    [self reloadIndicatorContent];
+    [self reloadAnimation];
+}
+
+- (void)awakeFromNib {
+    [self reloadAnimation];
+}
+
+- (void)reloadIndicatorContent {
+    self.progressIndicatorLayer.contents = [self progressImage];
+}
+
+- (void)reloadAnimation {
+    [self.progressIndicatorLayer removeAnimationForKey:kITSpinAnimationKey];
+
+    if (self.animates) {
+        [self.progressIndicatorLayer addAnimation:[self keyFrameAnimationForCurrentPreferences] forKey:kITSpinAnimationKey];
+    }
+}
+
+
+#pragma mark - Drawing
+
+- (NSImage *)progressImage {
+    NSImage *progressImage = [[NSImage alloc] initWithSize:self.bounds.size];
+    [progressImage lockFocus];
+    {
+        [NSGraphicsContext saveGraphicsState];
+        {
+            [self.color set];
+
+            NSRect r = self.bounds;
+            NSBezierPath *line = [NSBezierPath bezierPathWithRoundedRect:
+                                  NSMakeRect((NSWidth(r) / 2) - (self.widthOfLine / 2),
+                                             (NSHeight(r) / 2) - self.innerMargin - self.lengthOfLine,
+                                             self.widthOfLine, self.lengthOfLine)
+                                                                 xRadius:self.widthOfLine / 2
+                                                                 yRadius:self.widthOfLine / 2];
+
+            void (^lineDrawingBlock)(NSUInteger line) =
+            ^(NSUInteger lineNumber) {
+                NSBezierPath *lineInstance = [line copy];
+                lineInstance = [lineInstance it_rotatedBezierPath:((2 * M_PI) / self.numberOfLines * lineNumber) + M_PI
+                                                       aboutPoint:NSMakePoint(NSWidth(r) / 2, NSHeight(r) / 2)];
+
+                if (_isIndeterminate) [[self.color colorWithAlphaComponent:1.0 - (1.0 / self.numberOfLines * lineNumber)] set];
+
+                [lineInstance fill];
+            };
+
+            if (!self.isIndeterminate) {
+                for (NSUInteger i = self.numberOfLines;
+                     i > round(self.numberOfLines - (self.numberOfLines * self.progress));
+                     i--)
+                {
+                    lineDrawingBlock(i);
+                }
+            } else {
+                for (NSUInteger i = 0; i < self.numberOfLines; i++) {
+                    lineDrawingBlock(i);
+                }
+            }
+        }
+        [NSGraphicsContext restoreGraphicsState];
+    }
+    [progressImage unlockFocus];
+
+    return progressImage;
+}
+
+
+#pragma mark - Helpers
+
+- (CAKeyframeAnimation *)keyFrameAnimationForCurrentPreferences {
+    NSMutableArray* keyFrameValues = [NSMutableArray array];
+    NSMutableArray* keyTimeValues;
+
+    if (self.steppedAnimation) {
+        {
+            [keyFrameValues addObject:[NSNumber numberWithFloat:0.0]];
+            for (NSUInteger i = 0; i < self.numberOfLines; i++) {
+                [keyFrameValues addObject:[NSNumber numberWithFloat:-M_PI * (2.0 / self.numberOfLines * i)]];
+                [keyFrameValues addObject:[NSNumber numberWithFloat:-M_PI * (2.0 / self.numberOfLines * i)]];
+            }
+            [keyFrameValues addObject:[NSNumber numberWithFloat:-M_PI*2.0]];
+        }
+
+        keyTimeValues = [NSMutableArray array];
+        {
+            [keyTimeValues addObject:[NSNumber numberWithFloat:0.0]];
+            for (NSUInteger i = 0; i < (self.numberOfLines - 1); i++) {
+                [keyTimeValues addObject:[NSNumber numberWithFloat:1.0 / self.numberOfLines * i]];
+                [keyTimeValues addObject:[NSNumber numberWithFloat:1.0 / self.numberOfLines * (i + 1)]];
+            }
+            [keyTimeValues addObject:[NSNumber numberWithFloat:1.0 / self.numberOfLines * (self.numberOfLines - 1)]];
+        }
+    } else {
+        {
+            [keyFrameValues addObject:[NSNumber numberWithFloat:-M_PI*0.0]];
+            [keyFrameValues addObject:[NSNumber numberWithFloat:-M_PI*0.5]];
+            [keyFrameValues addObject:[NSNumber numberWithFloat:-M_PI*1.0]];
+            [keyFrameValues addObject:[NSNumber numberWithFloat:-M_PI*1.5]];
+            [keyFrameValues addObject:[NSNumber numberWithFloat:-M_PI*2.0]];
+        }
+    }
+
+
+    CAKeyframeAnimation* animation = [CAKeyframeAnimation animationWithKeyPath:@"transform"];
+
+    [animation setRepeatCount:HUGE_VALF];
+    [animation setValues:keyFrameValues];
+    [animation setKeyTimes:keyTimeValues];
+    [animation setValueFunction:[CAValueFunction functionWithName: kCAValueFunctionRotateZ]];
+    [animation setDuration:self.animationDuration];
+
+    return animation;
+}
+
+- (void)reloadVisibility {
+    if (_hideWhenStopped && !_animates && _isIndeterminate) {
+        [self setHidden:YES];
+    } else {
+        [self setHidden:NO];
+    }
+}
+
+
+#pragma mark - NSView methods
+
+// Animatible proxy
++ (id)defaultAnimationForKey:(NSString *)key
+{
+    if ([key isEqualToString:kITProgressPropertyKey]) {
+        return [CABasicAnimation animation];
+    } else {
+        return [super defaultAnimationForKey:key];
+    }
+}
+
+
+#pragma mark - Setters & Getters
+
+- (void)setIndeterminate:(BOOL)isIndeterminate {
+    _isIndeterminate = isIndeterminate;
+
+    if (!_isIndeterminate) {
+        self.animates = NO;
+    }
+}
+
+- (void)setProgress:(CGFloat)progress {
+    if (progress < 0 || progress > 1) {
+        @throw [NSException exceptionWithName:@"Invalid `progress` property value"
+                                       reason:@"`progress` property needs to be between 0 and 1"
+                                     userInfo:nil];
+    }
+
+    _progress = progress;
+
+    if (!self.isIndeterminate) {
+        [self reloadIndicatorContent];
+    }
+}
+
+- (void)setAnimates:(BOOL)animates {
+    _animates = animates;
+    [self reloadIndicatorContent];
+    [self reloadAnimation];
+    [self reloadVisibility];
+}
+
+- (void)setHideWhenStopped:(BOOL)hideWhenStopped {
+    _hideWhenStopped = hideWhenStopped;
+    [self reloadVisibility];
+}
+
+- (CALayer *)progressIndicatorLayer {
+    if (!_progressIndicatorLayer) {
+        _progressIndicatorLayer = [CALayer layer];
+    }
+
+    return _progressIndicatorLayer;
+}
+
+- (void)setLengthOfLine:(CGFloat)lengthOfLine {
+    _lengthOfLine = lengthOfLine;
+    [self reloadIndicatorContent];
+}
+
+- (void)setWidthOfLine:(CGFloat)widthOfLine {
+    _widthOfLine = widthOfLine;
+    [self reloadIndicatorContent];
+}
+
+- (void)setInnerMargin:(CGFloat)innerMargin {
+    _innerMargin = innerMargin;
+    [self reloadIndicatorContent];
+}
+
+- (void)setAnimationDuration:(CGFloat)animationDuration {
+    _animationDuration = animationDuration;
+    [self reloadAnimation];
+}
+
+- (void)setNumberOfLines:(NSUInteger)numberOfLines {
+    _numberOfLines = numberOfLines;
+    [self reloadIndicatorContent];
+    [self reloadAnimation];
+}
+
+- (void)setSteppedAnimation:(BOOL)steppedAnimation {
+    _steppedAnimation = steppedAnimation;
+    [self reloadAnimation];
+}
+
+- (void)setColor:(NSColor *)color {
+    _color = color;
+    [self reloadIndicatorContent];
+}
+
+@end