diff --git a/src/Avalonia.Animation/Animation.cs b/src/Avalonia.Animation/Animation.cs
index aa436f5f4e..4e777b36ed 100644
--- a/src/Avalonia.Animation/Animation.cs
+++ b/src/Avalonia.Animation/Animation.cs
@@ -68,7 +68,7 @@ namespace Avalonia.Animation
         /// <summary>
         /// The value fill mode for this animation.
         /// </summary>
-        public FillMode FillMode { get; set; } 
+        public FillMode FillMode { get; set; }
 
         /// <summary>
         /// Easing function to be used.
@@ -80,10 +80,10 @@ namespace Avalonia.Animation
             this.CollectionChanged += delegate { _isChildrenChanged = true; };
         }
  
-        private void InterpretKeyframes()
+        private IList<IAnimator> InterpretKeyframes(Animatable control)
         {
-            var handlerList = new List<(Type, AvaloniaProperty)>();
-            var kfList = new List<AnimatorKeyFrame>();
+            var handlerList = new List<(Type type, AvaloniaProperty property)>();
+            var animatorKeyFrames = new List<AnimatorKeyFrame>();
 
             foreach (var keyframe in this)
             {
@@ -99,41 +99,38 @@ namespace Avalonia.Animation
                     if (!handlerList.Contains((handler, setter.Property)))
                         handlerList.Add((handler, setter.Property));
 
-                    var newKF = new AnimatorKeyFrame()
+                    var cue = keyframe.Cue;
+
+                    if (keyframe.TimingMode == KeyFrameTimingMode.TimeSpan)
                     {
-                        Handler = handler,
-                        Property = setter.Property,
-                        Cue = keyframe.Cue,
-                        KeyTime = keyframe.KeyTime,
-                        timeSpanSet = keyframe.timeSpanSet,
-                        cueSet = keyframe.cueSet,
-                        Value = setter.Value
-                    };
-
-                    kfList.Add(newKF);
+                        cue = new Cue(keyframe.KeyTime.Ticks / Duration.Ticks);
+                    }
+
+                    var newKF = new AnimatorKeyFrame(handler, cue);
+
+                    _subscription.Add(newKF.BindSetter(setter, control));
+
+                    animatorKeyFrames.Add(newKF);
                 }
             }
 
-            var newAnimatorInstances = new List<(Type handler, AvaloniaProperty prop, IAnimator inst)>();
+            var newAnimatorInstances = new List<IAnimator>();
 
-            foreach (var handler in handlerList)
+            foreach (var (handlerType, property) in handlerList)
             {
-                var newInstance = (IAnimator)Activator.CreateInstance(handler.Item1);
-                newInstance.Property = handler.Item2;
-                newAnimatorInstances.Add((handler.Item1, handler.Item2, newInstance));
+                var newInstance = (IAnimator)Activator.CreateInstance(handlerType);
+                newInstance.Property = property;
+                newAnimatorInstances.Add(newInstance);
             }
 
-            foreach (var kf in kfList)
+            foreach (var keyframe in animatorKeyFrames)
             {
-                var parent = newAnimatorInstances.Where(p => p.handler == kf.Handler &&
-                                                             p.prop == kf.Property)
-                                                 .First();
-                parent.inst.Add(kf);
+                var animator = newAnimatorInstances.First(a => a.GetType() == keyframe.AnimatorType &&
+                                                             a.Property == keyframe.Property);
+                animator.Add(keyframe);
             }
 
-            foreach(var instance in newAnimatorInstances)
-                _animators.Add(instance.inst);
-
+            return newAnimatorInstances;
         }
 
         /// <summary>
@@ -150,17 +147,11 @@ namespace Avalonia.Animation
         /// <inheritdocs/>
         public IDisposable Apply(Animatable control, IObservable<bool> matchObs)
         {
-            if (_isChildrenChanged)
-            {
-                InterpretKeyframes();
-                _isChildrenChanged = false;
-            }
-
-            foreach (IAnimator keyframes in _animators)
+            foreach (IAnimator animator in InterpretKeyframes(control))
             {
-                _subscription.Add(keyframes.Apply(this, control, matchObs));
+                _subscription.Add(animator.Apply(this, control, matchObs));
             }
             return this;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Animation/AnimatorKeyFrame.cs b/src/Avalonia.Animation/AnimatorKeyFrame.cs
index 02457cb9aa..bd9c7a0184 100644
--- a/src/Avalonia.Animation/AnimatorKeyFrame.cs
+++ b/src/Avalonia.Animation/AnimatorKeyFrame.cs
@@ -4,6 +4,8 @@ using System.Text;
 using System.ComponentModel;
 using Avalonia.Metadata;
 using Avalonia.Collections;
+using Avalonia.Data;
+using Avalonia.Reactive;
 
 namespace Avalonia.Animation
 {
@@ -11,13 +13,63 @@ namespace Avalonia.Animation
     /// Defines a KeyFrame that is used for
     /// <see cref="Animator{T}"/> objects.
     /// </summary>
-    public class AnimatorKeyFrame
+    public class AnimatorKeyFrame : AvaloniaObject
     {
-        public Type Handler;
-        public Cue Cue;
-        public TimeSpan KeyTime;
-        internal bool timeSpanSet, cueSet;
-        public AvaloniaProperty Property;
-        public object Value;
+        public static readonly DirectProperty<AnimatorKeyFrame, object> ValueProperty =
+            AvaloniaProperty.RegisterDirect<AnimatorKeyFrame, object>(nameof(Value), k => k._value, (k, v) => k._value = v);
+
+        public AnimatorKeyFrame()
+        {
+
+        }
+
+        public AnimatorKeyFrame(Type animatorType, Cue cue)
+        {
+            AnimatorType = animatorType;
+            Cue = cue;
+        }
+
+        public Type AnimatorType { get; }
+        public Cue Cue { get; }
+        public AvaloniaProperty Property { get; private set; }
+
+        private object _value;
+
+        public object Value
+        {
+            get => _value;
+            set => SetAndRaise(ValueProperty, ref _value, value);
+        }
+
+        public IDisposable BindSetter(IAnimationSetter setter, Animatable targetControl)
+        {
+            Property = setter.Property;
+            var value = setter.Value;
+
+            if (value is IBinding binding)
+            {
+                return this.Bind(ValueProperty, binding, targetControl);
+            }
+            else
+            {
+                return this.Bind(ValueProperty, ObservableEx.SingleValue(value).ToBinding(), targetControl);
+            }
+        }
+
+        public T GetTypedValue<T>()
+        {
+            var typeConv = TypeDescriptor.GetConverter(typeof(T));
+
+            if (Value == null)
+            {
+                throw new ArgumentNullException($"KeyFrame value can't be null.");
+            }
+            if (!typeConv.CanConvertTo(Value.GetType()))
+            {
+                throw new InvalidCastException($"KeyFrame value doesnt match property type.");
+            }
+
+            return (T)typeConv.ConvertTo(Value, typeof(T));
+        }
     }
 }
diff --git a/src/Avalonia.Animation/AnimatorStateMachine`1.cs b/src/Avalonia.Animation/AnimatorStateMachine`1.cs
index e37b0e592a..1a51b897c0 100644
--- a/src/Avalonia.Animation/AnimatorStateMachine`1.cs
+++ b/src/Avalonia.Animation/AnimatorStateMachine`1.cs
@@ -51,9 +51,9 @@ namespace Avalonia.Animation
             Disposed
         }
 
-        public void Initialize(Animation animation, Animatable control, Animator<T> keyframes)
+        public void Initialize(Animation animation, Animatable control, Animator<T> animator)
         {
-            _parent = keyframes;
+            _parent = animator;
             _targetAnimation = animation;
             _targetControl = control;
             _neutralValue = (T)_targetControl.GetValue(_parent.Property);
@@ -123,121 +123,133 @@ namespace Avalonia.Animation
 
             double _tempDuration = 0d, _easedTime;
 
-        checkstate:
-            switch (_currentState)
+            bool handled = false;
+
+            while (!handled)
             {
-                case KeyFramesStates.DoDelay:
+                switch (_currentState)
+                {
+                    case KeyFramesStates.DoDelay:
 
-                    if (_fillMode == FillMode.Backward
-                     || _fillMode == FillMode.Both)
-                    {
-                        if (_currentIteration == 0)
+                        if (_fillMode == FillMode.Backward
+                         || _fillMode == FillMode.Both)
                         {
-                            _targetObserver.OnNext(_firstKFValue);
+                            if (_currentIteration == 0)
+                            {
+                                _targetObserver.OnNext(_firstKFValue);
+                            }
+                            else
+                            {
+                                _targetObserver.OnNext(_lastInterpValue);
+                            }
+                        }
+
+                        if (_delayFrameCount > _delayTotalFrameCount)
+                        {
+                            _currentState = KeyFramesStates.DoRun;
                         }
                         else
                         {
-                            _targetObserver.OnNext(_lastInterpValue);
+                            handled = true;
+                            _delayFrameCount++;
                         }
-                    }
-
-                    if (_delayFrameCount > _delayTotalFrameCount)
-                    {
-                        _currentState = KeyFramesStates.DoRun;
-                        goto checkstate;
-                    }
-                    _delayFrameCount++;
-                    break;
-
-                case KeyFramesStates.DoRun:
-
-                    if (_isReversed)
-                        _currentState = KeyFramesStates.RunBackwards;
-                    else
-                        _currentState = KeyFramesStates.RunForwards;
-
-                    goto checkstate;
-
-                case KeyFramesStates.RunForwards:
-
-                    if (_durationFrameCount > _durationTotalFrameCount)
-                    {
-                        _currentState = KeyFramesStates.RunComplete;
-                        goto checkstate;
-                    }
+                        break;
 
-                    _tempDuration = (double)_durationFrameCount / _durationTotalFrameCount;
-                    _currentState = KeyFramesStates.RunApplyValue;
+                    case KeyFramesStates.DoRun:
 
-                    goto checkstate;
+                        if (_isReversed)
+                            _currentState = KeyFramesStates.RunBackwards;
+                        else
+                            _currentState = KeyFramesStates.RunForwards;
 
-                case KeyFramesStates.RunBackwards:
+                        break;
 
-                    if (_durationFrameCount > _durationTotalFrameCount)
-                    {
-                        _currentState = KeyFramesStates.RunComplete;
-                        goto checkstate;
-                    }
+                    case KeyFramesStates.RunForwards:
 
-                    _tempDuration = (double)(_durationTotalFrameCount - _durationFrameCount) / _durationTotalFrameCount;
-                    _currentState = KeyFramesStates.RunApplyValue;
+                        if (_durationFrameCount > _durationTotalFrameCount)
+                        {
+                            _currentState = KeyFramesStates.RunComplete;
+                        }
+                        else
+                        {
+                            _tempDuration = (double)_durationFrameCount / _durationTotalFrameCount;
+                            _currentState = KeyFramesStates.RunApplyValue;
 
-                    goto checkstate;
+                        }
+                        break;
 
-                case KeyFramesStates.RunApplyValue:
+                    case KeyFramesStates.RunBackwards:
 
-                    _easedTime = _targetAnimation.Easing.Ease(_tempDuration);
+                        if (_durationFrameCount > _durationTotalFrameCount)
+                        {
+                            _currentState = KeyFramesStates.RunComplete;
+                        }
+                        else
+                        {
+                            _tempDuration = (double)(_durationTotalFrameCount - _durationFrameCount) / _durationTotalFrameCount;
+                            _currentState = KeyFramesStates.RunApplyValue;
+                        }
+                        break;
 
-                    _durationFrameCount++;
-                    _lastInterpValue = Interpolator(_easedTime, _neutralValue);
-                    _targetObserver.OnNext(_lastInterpValue);
-                    _currentState = KeyFramesStates.DoRun;
+                    case KeyFramesStates.RunApplyValue:
 
-                    break;
+                        _easedTime = _targetAnimation.Easing.Ease(_tempDuration);
 
-                case KeyFramesStates.RunComplete:
+                        _durationFrameCount++;
+                        _lastInterpValue = Interpolator(_easedTime, _neutralValue);
+                        _targetObserver.OnNext(_lastInterpValue);
+                        _currentState = KeyFramesStates.DoRun;
+                        handled = true;
+                        break;
 
-                    if (_checkLoopAndRepeat)
-                    {
-                        _delayFrameCount = 0;
-                        _durationFrameCount = 0;
+                    case KeyFramesStates.RunComplete:
 
-                        if (_isLooping)
-                        {
-                            _currentState = KeyFramesStates.DoRun;
-                        }
-                        else if (_isRepeating)
+                        if (_checkLoopAndRepeat)
                         {
-                            if (_currentIteration >= _repeatCount)
+                            _delayFrameCount = 0;
+                            _durationFrameCount = 0;
+
+                            if (_isLooping)
                             {
-                                _currentState = KeyFramesStates.Stop;
+                                _currentState = KeyFramesStates.DoRun;
                             }
-                            else
+                            else if (_isRepeating)
                             {
-                                _currentState = KeyFramesStates.DoRun;
+                                if (_currentIteration >= _repeatCount)
+                                {
+                                    _currentState = KeyFramesStates.Stop;
+                                }
+                                else
+                                {
+                                    _currentState = KeyFramesStates.DoRun;
+                                }
+                                _currentIteration++;
                             }
-                            _currentIteration++;
-                        }
 
-                        if (_animationDirection == PlaybackDirection.Alternate
-                         || _animationDirection == PlaybackDirection.AlternateReverse)
-                            _isReversed = !_isReversed;
+                            if (_animationDirection == PlaybackDirection.Alternate
+                             || _animationDirection == PlaybackDirection.AlternateReverse)
+                                _isReversed = !_isReversed;
 
-                        break;
-                    }
+                            break;
+                        }
 
-                    _currentState = KeyFramesStates.Stop;
-                    goto checkstate;
+                        _currentState = KeyFramesStates.Stop;
+                        break;
 
-                case KeyFramesStates.Stop:
+                    case KeyFramesStates.Stop:
 
-                    if (_fillMode == FillMode.Forward
-                     || _fillMode == FillMode.Both)
-                    {
-                        _targetControl.SetValue(_parent.Property, _lastInterpValue, BindingPriority.LocalValue);
-                    }
-                    _targetObserver.OnCompleted();
-                    break;
+                        if (_fillMode == FillMode.Forward
+                         || _fillMode == FillMode.Both)
+                        {
+                            _targetControl.SetValue(_parent.Property, _lastInterpValue, BindingPriority.LocalValue);
+                        }
+                        _targetObserver.OnCompleted();
+                        handled = true;
+                        break;
+                    default:
+                        handled = true;
+                        break;
+                }
             }
         }
 
@@ -253,4 +265,4 @@ namespace Avalonia.Animation
             _currentState = KeyFramesStates.Disposed;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Animation/Animator`1.cs b/src/Avalonia.Animation/Animator`1.cs
index 6d4ae7d8e2..a1eef87e1e 100644
--- a/src/Avalonia.Animation/Animator`1.cs
+++ b/src/Avalonia.Animation/Animator`1.cs
@@ -19,7 +19,7 @@ namespace Avalonia.Animation
         /// <summary>
         /// List of type-converted keyframes.
         /// </summary>
-        private Dictionary<double, (T, bool isNeutral)> _convertedKeyframes = new Dictionary<double, (T, bool)>();
+        private readonly SortedList<double, (AnimatorKeyFrame, bool isNeutral)> _convertedKeyframes = new SortedList<double, (AnimatorKeyFrame, bool)>();
 
         private bool _isVerfifiedAndConverted;
 
@@ -38,12 +38,11 @@ namespace Avalonia.Animation
         public virtual IDisposable Apply(Animation animation, Animatable control, IObservable<bool> obsMatch)
         {
             if (!_isVerfifiedAndConverted)
-                VerifyConvertKeyFrames(animation, typeof(T));
+                VerifyConvertKeyFrames();
 
             return obsMatch
-                .Where(p => p == true)
                 // Ignore triggers when global timers are paused.
-                .Where(p => Timing.GetGlobalPlayState() != PlayState.Pause)
+                .Where(p => p && Timing.GetGlobalPlayState() != PlayState.Pause)
                 .Subscribe(_ =>
                 {
                     var timerObs = RunKeyFrames(animation, control);
@@ -60,8 +59,8 @@ namespace Avalonia.Animation
         /// <param name="t">The time parameter, relative to the total animation time</param>
         protected (double IntraKFTime, KeyFramePair<T> KFPair) GetKFPairAndIntraKFTime(double t)
         {
-            KeyValuePair<double, (T, bool)> firstCue, lastCue;
-            int kvCount = _convertedKeyframes.Count();
+            KeyValuePair<double, (AnimatorKeyFrame frame, bool isNeutral)> firstCue, lastCue;
+            int kvCount = _convertedKeyframes.Count;
             if (kvCount > 2)
             {
                 if (DoubleUtils.AboutEqual(t, 0.0) || t < 0.0)
@@ -76,8 +75,8 @@ namespace Avalonia.Animation
                 }
                 else
                 {
-                    firstCue = _convertedKeyframes.Where(j => j.Key <= t).Last();
-                    lastCue = _convertedKeyframes.Where(j => j.Key >= t).First();
+                    firstCue = _convertedKeyframes.Last(j => j.Key <= t);
+                    lastCue = _convertedKeyframes.First(j => j.Key >= t);
                 }
             }
             else
@@ -89,7 +88,9 @@ namespace Avalonia.Animation
             double t0 = firstCue.Key;
             double t1 = lastCue.Key;
             var intraframeTime = (t - t0) / (t1 - t0);
-            return (intraframeTime, new KeyFramePair<T>(firstCue, lastCue));
+            var firstFrameData = (firstCue.Value.frame.GetTypedValue<T>(), firstCue.Value.isNeutral);
+            var lastFrameData = (lastCue.Value.frame.GetTypedValue<T>(), lastCue.Value.isNeutral);
+            return (intraframeTime, new KeyFramePair<T>(firstFrameData, lastFrameData));
         }
 
 
@@ -98,17 +99,14 @@ namespace Avalonia.Animation
         /// </summary>
         private IDisposable RunKeyFrames(Animation animation, Animatable control)
         {
-            var _kfStateMach = new AnimatorStateMachine<T>();
-            _kfStateMach.Initialize(animation, control, this);
+            var stateMachine = new AnimatorStateMachine<T>();
+            stateMachine.Initialize(animation, control, this);
 
             Timing.AnimationStateTimer
-                        .TakeWhile(_ => !_kfStateMach._unsubscribe)
-                        .Subscribe(p =>
-                        {
-                            _kfStateMach.Step(p, DoInterpolation);
-                        });
+                        .TakeWhile(_ => !stateMachine._unsubscribe)
+                        .Subscribe(p => stateMachine.Step(p, DoInterpolation));
 
-            return control.Bind(Property, _kfStateMach, BindingPriority.Animation);
+            return control.Bind(Property, stateMachine, BindingPriority.Animation);
         }
 
         /// <summary>
@@ -119,39 +117,19 @@ namespace Avalonia.Animation
         /// <summary>
         /// Verifies and converts keyframe values according to this class's target type.
         /// </summary>
-        private void VerifyConvertKeyFrames(Animation animation, Type type)
+        private void VerifyConvertKeyFrames()
         {
-            var typeConv = TypeDescriptor.GetConverter(type);
-
-            foreach (AnimatorKeyFrame k in this)
+            foreach (AnimatorKeyFrame keyframe in this)
             {
-                if (k.Value == null)
-                {
-                    throw new ArgumentNullException($"KeyFrame value can't be null.");
-                }
-                if (!typeConv.CanConvertTo(k.Value.GetType()))
-                {
-                    throw new InvalidCastException($"KeyFrame value doesnt match property type.");
-                }
-
-                T convertedValue = (T)typeConv.ConvertTo(k.Value, type);
-
-                Cue _normalizedCue = k.Cue;
-
-                if (k.timeSpanSet)
-                {
-                    _normalizedCue = new Cue(k.KeyTime.Ticks / animation.Duration.Ticks);
-                }
-
-                _convertedKeyframes.Add(_normalizedCue.CueValue, (convertedValue, false));
+                _convertedKeyframes.Add(keyframe.Cue.CueValue, (keyframe, false));
             }
 
-            SortKeyFrameCues(_convertedKeyframes);
+            AddNeutralKeyFramesIfNeeded();
             _isVerfifiedAndConverted = true;
 
         }
 
-        private void SortKeyFrameCues(Dictionary<double, (T, bool)> convertedValues)
+        private void AddNeutralKeyFramesIfNeeded()
         {
             bool hasStartKey, hasEndKey;
             hasStartKey = hasEndKey = false;
@@ -170,23 +148,20 @@ namespace Avalonia.Animation
             }
 
             if (!hasStartKey || !hasEndKey)
-                AddNeutralKeyFrames(hasStartKey, hasEndKey, _convertedKeyframes);
-
-            _convertedKeyframes = _convertedKeyframes.OrderBy(p => p.Key)
-                                                     .ToDictionary((k) => k.Key, (v) => v.Value);
+                AddNeutralKeyFrames(hasStartKey, hasEndKey);
         }
 
-        private void AddNeutralKeyFrames(bool hasStartKey, bool hasEndKey, Dictionary<double, (T, bool)> convertedKeyframes)
+        private void AddNeutralKeyFrames(bool hasStartKey, bool hasEndKey)
         {
             if (!hasStartKey)
             {
-                convertedKeyframes.Add(0.0d, (default(T), true));
+                _convertedKeyframes.Add(0.0d, (new AnimatorKeyFrame { Value = default(T) }, true));
             }
 
             if (!hasEndKey)
             {
-                convertedKeyframes.Add(1.0d, (default(T), true));
+                _convertedKeyframes.Add(1.0d, (new AnimatorKeyFrame { Value = default(T) }, true));
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Animation/Cue.cs b/src/Avalonia.Animation/Cue.cs
index fe36b13495..5a95c108e3 100644
--- a/src/Avalonia.Animation/Cue.cs
+++ b/src/Avalonia.Animation/Cue.cs
@@ -10,7 +10,7 @@ namespace Avalonia.Animation
     /// A Cue object for <see cref="KeyFrame"/>. 
     /// </summary>
     [TypeConverter(typeof(CueTypeConverter))]
-    public struct Cue : IEquatable<Cue>, IEquatable<double>
+    public readonly struct Cue : IEquatable<Cue>, IEquatable<double>
     {
         /// <summary>
         /// The normalized percent value, ranging from 0.0 to 1.0
diff --git a/src/Avalonia.Animation/DoubleAnimator.cs b/src/Avalonia.Animation/DoubleAnimator.cs
index 5b994377f1..154f37360c 100644
--- a/src/Avalonia.Animation/DoubleAnimator.cs
+++ b/src/Avalonia.Animation/DoubleAnimator.cs
@@ -24,15 +24,15 @@ namespace Avalonia.Animation
             var firstKF = pair.KFPair.FirstKeyFrame;
             var secondKF = pair.KFPair.SecondKeyFrame;
 
-            if (firstKF.Value.isNeutral)
+            if (firstKF.isNeutral)
                 y0 = neutralValue;
             else
-                y0 = firstKF.Value.TargetValue;
+                y0 = firstKF.TargetValue;
 
-            if (secondKF.Value.isNeutral)
+            if (secondKF.isNeutral)
                 y1 = neutralValue;
             else
-                y1 = secondKF.Value.TargetValue;
+                y1 = secondKF.TargetValue;
 
             // Do linear parametric interpolation 
             return y0 + (pair.IntraKFTime) * (y1 - y0);
diff --git a/src/Avalonia.Animation/IAnimationSetter.cs b/src/Avalonia.Animation/IAnimationSetter.cs
index f2a94c9ed6..2d22377286 100644
--- a/src/Avalonia.Animation/IAnimationSetter.cs
+++ b/src/Avalonia.Animation/IAnimationSetter.cs
@@ -5,4 +5,4 @@ namespace Avalonia.Animation
         AvaloniaProperty Property { get; set; }
         object Value { get; set; }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Animation/KeyFrame.cs b/src/Avalonia.Animation/KeyFrame.cs
index 46be119c36..ea04aa0aab 100644
--- a/src/Avalonia.Animation/KeyFrame.cs
+++ b/src/Avalonia.Animation/KeyFrame.cs
@@ -7,6 +7,11 @@ using Avalonia.Collections;
 
 namespace Avalonia.Animation
 {
+    internal enum KeyFrameTimingMode
+    {
+        TimeSpan = 1,
+        Cue
+    }
 
     /// <summary>
     /// Stores data regarding a specific key
@@ -14,7 +19,6 @@ namespace Avalonia.Animation
     /// </summary>
     public class KeyFrame : AvaloniaList<IAnimationSetter>
     {
-        internal bool timeSpanSet, cueSet;
         private TimeSpan _ktimeSpan;
         private Cue _kCue;
 
@@ -30,6 +34,8 @@ namespace Avalonia.Animation
         {
         }
 
+        internal KeyFrameTimingMode TimingMode { get; private set; }
+
         /// <summary>
         /// Gets or sets the key time of this <see cref="KeyFrame"/>.
         /// </summary>
@@ -42,11 +48,11 @@ namespace Avalonia.Animation
             }
             set
             {
-                if (cueSet)
+                if (TimingMode == KeyFrameTimingMode.Cue)
                 {
                     throw new InvalidOperationException($"You can only set either {nameof(KeyTime)} or {nameof(Cue)}.");
                 }
-                timeSpanSet = true;
+                TimingMode = KeyFrameTimingMode.TimeSpan;
                 _ktimeSpan = value;
             }
         }
@@ -63,11 +69,11 @@ namespace Avalonia.Animation
             }
             set
             {
-                if (timeSpanSet)
+                if (TimingMode == KeyFrameTimingMode.TimeSpan)
                 {
                     throw new InvalidOperationException($"You can only set either {nameof(KeyTime)} or {nameof(Cue)}.");
                 }
-                cueSet = true;
+                TimingMode = KeyFrameTimingMode.Cue;
                 _kCue = value;
             }
         }
diff --git a/src/Avalonia.Animation/KeyFramePair`1.cs b/src/Avalonia.Animation/KeyFramePair`1.cs
index c192479a1d..408b13e0d8 100644
--- a/src/Avalonia.Animation/KeyFramePair`1.cs
+++ b/src/Avalonia.Animation/KeyFramePair`1.cs
@@ -22,7 +22,7 @@ namespace Avalonia.Animation
         /// </summary>
         /// <param name="FirstKeyFrame"></param>
         /// <param name="LastKeyFrame"></param>
-        public KeyFramePair(KeyValuePair<double, (T, bool)> FirstKeyFrame, KeyValuePair<double, (T, bool)> LastKeyFrame) : this()
+        public KeyFramePair((T TargetValue, bool isNeutral) FirstKeyFrame, (T TargetValue, bool isNeutral) LastKeyFrame) : this()
         {
             this.FirstKeyFrame = FirstKeyFrame;
             this.SecondKeyFrame = LastKeyFrame;
@@ -31,11 +31,11 @@ namespace Avalonia.Animation
         /// <summary>
         /// First <see cref="KeyFrame"/> object.
         /// </summary>
-        public KeyValuePair<double, (T TargetValue, bool isNeutral)> FirstKeyFrame { get; private set; }
+        public (T TargetValue, bool isNeutral) FirstKeyFrame { get; }
 
         /// <summary>
         /// Second <see cref="KeyFrame"/> object.
         /// </summary>
-        public KeyValuePair<double, (T TargetValue, bool isNeutral)> SecondKeyFrame { get; private set; }
+        public (T TargetValue, bool isNeutral) SecondKeyFrame { get; }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Base/AvaloniaPropertyRegistry.cs b/src/Avalonia.Base/AvaloniaPropertyRegistry.cs
index c0a4ace6ed..e29e7339ae 100644
--- a/src/Avalonia.Base/AvaloniaPropertyRegistry.cs
+++ b/src/Avalonia.Base/AvaloniaPropertyRegistry.cs
@@ -106,7 +106,7 @@ namespace Avalonia
         }
 
         /// <summary>
-        /// Finds a registered non-attached property on a type by name.
+        /// Finds a registered property on a type by name.
         /// </summary>
         /// <param name="type">The type.</param>
         /// <param name="name">The property name.</param>
@@ -130,7 +130,7 @@ namespace Avalonia
         }
 
         /// <summary>
-        /// Finds a registered non-attached property on a type by name.
+        /// Finds a registered property on an object by name.
         /// </summary>
         /// <param name="o">The object.</param>
         /// <param name="name">The property name.</param>
@@ -148,52 +148,6 @@ namespace Avalonia
             return FindRegistered(o.GetType(), name);
         }
 
-        /// <summary>
-        /// Finds a registered attached property on a type by name.
-        /// </summary>
-        /// <param name="type">The type.</param>
-        /// <param name="ownerType">The owner type.</param>
-        /// <param name="name">The property name.</param>
-        /// <returns>
-        /// The registered property or null if no matching property found.
-        /// </returns>
-        /// <exception cref="InvalidOperationException">
-        /// The property name contains a '.'.
-        /// </exception>
-        public AvaloniaProperty FindRegisteredAttached(Type type, Type ownerType, string name)
-        {
-            Contract.Requires<ArgumentNullException>(type != null);
-            Contract.Requires<ArgumentNullException>(ownerType != null);
-            Contract.Requires<ArgumentNullException>(name != null);
-
-            if (name.Contains('.'))
-            {
-                throw new InvalidOperationException("Attached properties not supported.");
-            }
-
-            return GetRegisteredAttached(type).FirstOrDefault(x => x.Name == name);
-        }
-
-        /// <summary>
-        /// Finds a registered non-attached property on a type by name.
-        /// </summary>
-        /// <param name="o">The object.</param>
-        /// <param name="ownerType">The owner type.</param>
-        /// <param name="name">The property name.</param>
-        /// <returns>
-        /// The registered property or null if no matching property found.
-        /// </returns>
-        /// <exception cref="InvalidOperationException">
-        /// The property name contains a '.'.
-        /// </exception>
-        public AvaloniaProperty FindRegisteredAttached(AvaloniaObject o, Type ownerType, string name)
-        {
-            Contract.Requires<ArgumentNullException>(o != null);
-            Contract.Requires<ArgumentNullException>(name != null);
-
-            return FindRegisteredAttached(o.GetType(), ownerType, name);
-        }
-
         /// <summary>
         /// Checks whether a <see cref="AvaloniaProperty"/> is registered on a type.
         /// </summary>
@@ -287,4 +241,4 @@ namespace Avalonia
             _attachedCache.Clear();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/Reader.cs b/src/Avalonia.Base/Utilities/CharacterReader.cs
similarity index 89%
rename from src/Markup/Avalonia.Markup/Markup/Parsers/Reader.cs
rename to src/Avalonia.Base/Utilities/CharacterReader.cs
index 9355bc9aa3..0910d5b969 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/Reader.cs
+++ b/src/Avalonia.Base/Utilities/CharacterReader.cs
@@ -3,14 +3,14 @@
 
 using System;
 
-namespace Avalonia.Markup.Parsers
+namespace Avalonia.Utilities
 {
-    internal class Reader
+    public class CharacterReader
     {
         private readonly string _s;
         private int _i;
 
-        public Reader(string s)
+        public CharacterReader(string s)
         {
             _s = s;
         }
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/IdentifierParser.cs b/src/Avalonia.Base/Utilities/IdentifierParser.cs
similarity index 91%
rename from src/Markup/Avalonia.Markup/Markup/Parsers/IdentifierParser.cs
rename to src/Avalonia.Base/Utilities/IdentifierParser.cs
index f86f2db321..14b8affbdd 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/IdentifierParser.cs
+++ b/src/Avalonia.Base/Utilities/IdentifierParser.cs
@@ -4,11 +4,11 @@
 using System.Globalization;
 using System.Text;
 
-namespace Avalonia.Markup.Parsers
+namespace Avalonia.Utilities
 {
-    internal static class IdentifierParser
+    public static class IdentifierParser
     {
-        public static string Parse(Reader r)
+        public static string Parse(CharacterReader r)
         {
             if (IsValidIdentifierStart(r.Peek))
             {
diff --git a/src/Avalonia.Controls/ProgressBar.cs b/src/Avalonia.Controls/ProgressBar.cs
index 5e5a460368..b7db352c74 100644
--- a/src/Avalonia.Controls/ProgressBar.cs
+++ b/src/Avalonia.Controls/ProgressBar.cs
@@ -21,18 +21,27 @@ namespace Avalonia.Controls
         public static readonly StyledProperty<Orientation> OrientationProperty =
             AvaloniaProperty.Register<ProgressBar, Orientation>(nameof(Orientation), Orientation.Horizontal);
 
+        private static readonly DirectProperty<ProgressBar, double> IndeterminateStartingOffsetProperty =
+            AvaloniaProperty.RegisterDirect<ProgressBar, double>(
+                nameof(IndeterminateStartingOffset),
+                p => p.IndeterminateStartingOffset,
+                (p, o) => p.IndeterminateStartingOffset = o);
+
+        private static readonly DirectProperty<ProgressBar, double> IndeterminateEndingOffsetProperty =
+            AvaloniaProperty.RegisterDirect<ProgressBar, double>(
+                nameof(IndeterminateEndingOffset),
+                p => p.IndeterminateEndingOffset,
+                (p, o) => p.IndeterminateEndingOffset = o);
+
         private Border _indicator;
-        private IndeterminateAnimation _indeterminateAnimation;
 
         static ProgressBar()
         {
             PseudoClass(OrientationProperty, o => o == Avalonia.Controls.Orientation.Vertical, ":vertical");
             PseudoClass(OrientationProperty, o => o == Avalonia.Controls.Orientation.Horizontal, ":horizontal");
+            PseudoClass(IsIndeterminateProperty, ":indeterminate");
 
             ValueProperty.Changed.AddClassHandler<ProgressBar>(x => x.ValueChanged);
-
-            IsIndeterminateProperty.Changed.AddClassHandler<ProgressBar>(
-                (p, e) => { if (p._indicator != null) p.UpdateIsIndeterminate((bool)e.NewValue); });
         }
 
         public bool IsIndeterminate
@@ -46,6 +55,19 @@ namespace Avalonia.Controls
             get => GetValue(OrientationProperty);
             set => SetValue(OrientationProperty, value);
         }
+        private double _indeterminateStartingOffset;
+        private double IndeterminateStartingOffset
+        {
+            get => _indeterminateStartingOffset;
+            set => SetAndRaise(IndeterminateStartingOffsetProperty, ref _indeterminateStartingOffset, value);
+        }
+
+        private double _indeterminateEndingOffset;
+        private double IndeterminateEndingOffset
+        {
+            get => _indeterminateEndingOffset;
+            set => SetAndRaise(IndeterminateEndingOffsetProperty, ref _indeterminateEndingOffset, value);
+        }
 
         /// <inheritdoc/>
         protected override Size ArrangeOverride(Size finalSize)
@@ -60,7 +82,6 @@ namespace Avalonia.Controls
             _indicator = e.NameScope.Get<Border>("PART_Indicator");
 
             UpdateIndicator(Bounds.Size);
-            UpdateIsIndeterminate(IsIndeterminate);
         }
 
         private void UpdateIndicator(Size bounds)
@@ -70,9 +91,20 @@ namespace Avalonia.Controls
                 if (IsIndeterminate)
                 {
                     if (Orientation == Orientation.Horizontal)
-                        _indicator.Width = bounds.Width / 5.0;
+                    {
+                        var width = bounds.Width / 5.0;
+                        IndeterminateStartingOffset = -width;
+                        _indicator.Width = width;
+                        IndeterminateEndingOffset = bounds.Width;
+
+                    }
                     else
-                        _indicator.Height = bounds.Height / 5.0;
+                    {
+                        var height = bounds.Height / 5.0;
+                        IndeterminateStartingOffset = -bounds.Height;
+                        _indicator.Height = height;
+                        IndeterminateEndingOffset = height;
+                    }
                 }
                 else
                 {
@@ -86,53 +118,9 @@ namespace Avalonia.Controls
             }
         }
 
-        private void UpdateIsIndeterminate(bool isIndeterminate)
-        {
-            if (isIndeterminate)
-            {
-                if (_indeterminateAnimation == null || _indeterminateAnimation.Disposed)
-                    _indeterminateAnimation = IndeterminateAnimation.StartAnimation(this);
-            }
-            else
-                _indeterminateAnimation?.Dispose();
-        }
-
         private void ValueChanged(AvaloniaPropertyChangedEventArgs e)
         {
             UpdateIndicator(Bounds.Size);
         }
-
-        // TODO: Implement Indeterminate Progress animation
-        //       in xaml (most ideal) or if it's not possible
-        //       then on this class.
-        private class IndeterminateAnimation : IDisposable
-        {
-            private WeakReference<ProgressBar> _progressBar;
-
-            private bool _disposed;
-
-            public bool Disposed => _disposed;
-
-            private IndeterminateAnimation(ProgressBar progressBar)
-            {
-                _progressBar = new WeakReference<ProgressBar>(progressBar);
-
-            }
-
-            public static IndeterminateAnimation StartAnimation(ProgressBar progressBar)
-            {
-                return new IndeterminateAnimation(progressBar);
-            }
-
-            private Rect GetAnimationRect(TimeSpan time)
-            {
-                return Rect.Empty;
-            }
-
-            public void Dispose()
-            {
-                _disposed = true;
-            }
-        }
     }
 }
diff --git a/src/Avalonia.Styling/Styling/Setter.cs b/src/Avalonia.Styling/Styling/Setter.cs
index 31b685f6b1..c75bae4db8 100644
--- a/src/Avalonia.Styling/Styling/Setter.cs
+++ b/src/Avalonia.Styling/Styling/Setter.cs
@@ -126,7 +126,7 @@ namespace Avalonia.Styling
 
                 if (source != null)
                 {
-                    var cloned = Clone(source, style, activator);
+                    var cloned = Clone(source, source.Mode == BindingMode.Default ? Property.GetMetadata(control.GetType()).DefaultBindingMode : source.Mode, style, activator);
                     return BindingOperations.Apply(control, Property, cloned, null);
                 }
             }
@@ -134,13 +134,13 @@ namespace Avalonia.Styling
             return Disposable.Empty;
         }
 
-        private InstancedBinding Clone(InstancedBinding sourceInstance, IStyle style, IObservable<bool> activator)
+        private InstancedBinding Clone(InstancedBinding sourceInstance, BindingMode mode, IStyle style, IObservable<bool> activator)
         {
             if (activator != null)
             {
                 var description = style?.ToString();
 
-                switch (sourceInstance.Mode)
+                switch (mode)
                 {
                     case BindingMode.OneTime:
                         if (sourceInstance.Observable != null)
diff --git a/src/Avalonia.Themes.Default/ProgressBar.xaml b/src/Avalonia.Themes.Default/ProgressBar.xaml
index c9c898562c..c4cbfed350 100644
--- a/src/Avalonia.Themes.Default/ProgressBar.xaml
+++ b/src/Avalonia.Themes.Default/ProgressBar.xaml
@@ -7,14 +7,9 @@
         <Border Background="{TemplateBinding Background}"
                 BorderBrush="{TemplateBinding BorderBrush}"
                 BorderThickness="{TemplateBinding BorderThickness}">
-          <Grid>
-            <Border Name="PART_Track"
-                    BorderThickness="1"
-                    BorderBrush="{TemplateBinding Background}"/>
-            <Border Name="PART_Indicator"
-                    BorderThickness="1"
-                    Background="{TemplateBinding Foreground}" />
-          </Grid>
+          <Border Name="PART_Indicator"
+                  BorderThickness="1"
+                  Background="{TemplateBinding Foreground}"/>
         </Border>
       </ControlTemplate>
     </Setter>
@@ -35,4 +30,36 @@
     <Setter Property="MinWidth" Value="14"/>
     <Setter Property="MinHeight" Value="200"/>
   </Style>
-</Styles>
\ No newline at end of file
+  <Style Selector="ProgressBar:horizontal:indeterminate /template/ Border#PART_Indicator">
+      <Style.Animations>
+          <Animation Duration="0:0:3"
+                     RepeatCount="Loop"
+                     Easing="LinearEasing">
+              <KeyFrame Cue="0%">
+                  <Setter Property="TranslateTransform.X"
+                          Value="{Binding IndeterminateStartingOffset, RelativeSource={RelativeSource TemplatedParent}}" />
+              </KeyFrame>
+              <KeyFrame Cue="100%">
+                  <Setter Property="TranslateTransform.X"
+                          Value="{Binding IndeterminateEndingOffset, RelativeSource={RelativeSource TemplatedParent}}" />
+              </KeyFrame>
+      </Animation>
+      </Style.Animations>
+  </Style>
+  <Style Selector="ProgressBar:vertical:indeterminate /template/ Border#PART_Indicator">
+      <Style.Animations>
+          <Animation Duration="0:0:3"
+                     RepeatCount="Loop"
+                     Easing="LinearEasing">
+              <KeyFrame Cue="0%">
+                  <Setter Property="TranslateTransform.Y"
+                          Value="{Binding IndeterminateStartingOffset, RelativeSource={RelativeSource TemplatedParent}}" />
+              </KeyFrame>
+              <KeyFrame Cue="100%">
+                  <Setter Property="TranslateTransform.Y"
+                          Value="{Binding IndeterminateEndingOffset, RelativeSource={RelativeSource TemplatedParent}}" />
+              </KeyFrame>
+      </Animation>
+      </Style.Animations>
+  </Style>
+</Styles>
diff --git a/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj b/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj
index cdc22f4102..8c843a4b49 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj
+++ b/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj
@@ -33,6 +33,7 @@
         <Compile Include="MarkupExtensions\ResourceInclude.cs" />
         <Compile Include="MarkupExtensions\StaticResourceExtension.cs" />
         <Compile Include="MarkupExtensions\StyleIncludeExtension.cs" />
+        <Compile Include="Parsers\PropertyParser.cs" />
         <Compile Include="PortableXaml\AvaloniaXamlContext.cs" />
         <Compile Include="PortableXaml\AttributeExtensions.cs" />
         <Compile Include="PortableXaml\AvaloniaMemberAttributeProvider.cs" />
diff --git a/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs b/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
index 63b7811dbc..627a646bcf 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
@@ -4,19 +4,19 @@
 using System;
 using System.ComponentModel;
 using System.Globalization;
-using System.Text.RegularExpressions;
+using Avalonia.Controls;
+using Avalonia.Logging;
+using Avalonia.Markup.Parsers;
+using Avalonia.Markup.Xaml.Parsers;
 using Avalonia.Markup.Xaml.Templates;
 using Avalonia.Styling;
-using Portable.Xaml;
+using Avalonia.Utilities;
 using Portable.Xaml.ComponentModel;
-using Portable.Xaml.Markup;
 
 namespace Avalonia.Markup.Xaml.Converters
 {
     public class AvaloniaPropertyTypeConverter : TypeConverter
     {
-        private static readonly Regex regex = new Regex(@"^\(?(\w*)\.(\w*)\)?|(.*)$");
-
         public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
         {
             return sourceType == typeof(string);
@@ -24,39 +24,48 @@ namespace Avalonia.Markup.Xaml.Converters
 
         public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
         {
-            var (owner, propertyName) = ParseProperty((string)value);
-            var ownerType = TryResolveOwnerByName(context, owner) ??
-                context.GetFirstAmbientValue<ControlTemplate>()?.TargetType ??
-                context.GetFirstAmbientValue<Style>()?.Selector?.TargetType;
+            var registry = AvaloniaPropertyRegistry.Instance;
+            var parser = new PropertyParser();
+            var reader = new CharacterReader((string)value);
+            var (ns, owner, propertyName) = parser.Parse(reader);
+            var ownerType = TryResolveOwnerByName(context, ns, owner);
+            var targetType = context.GetFirstAmbientValue<ControlTemplate>()?.TargetType ??
+                context.GetFirstAmbientValue<Style>()?.Selector?.TargetType ??
+                typeof(Control);
+            var effectiveOwner = ownerType ?? targetType;
+            var property = registry.FindRegistered(effectiveOwner, propertyName);
 
-            if (ownerType == null)
+            if (property == null)
             {
-                throw new XamlLoadException(
-                    $"Could not determine the owner type for property '{propertyName}'. " +
-                    "Please fully qualify the property name or specify a target type on " +
-                    "the containing template.");
+                throw new XamlLoadException($"Could not find property '{effectiveOwner.Name}.{propertyName}'.");
             }
 
-            var property = AvaloniaPropertyRegistry.Instance.FindRegistered(ownerType, propertyName);
-
-            if (property == null)
+            if (effectiveOwner != targetType &&
+                !property.IsAttached &&
+                !registry.IsRegistered(targetType, property))
             {
-                throw new XamlLoadException($"Could not find AvaloniaProperty '{ownerType.Name}.{propertyName}'.");
+                Logger.Warning(
+                    LogArea.Property,
+                    this,
+                    "Property '{Owner}.{Name}' is not registered on '{Type}'.",
+                    effectiveOwner,
+                    propertyName,
+                    targetType);
             }
 
             return property;
         }
 
-        private Type TryResolveOwnerByName(ITypeDescriptorContext context, string owner)
+        private Type TryResolveOwnerByName(ITypeDescriptorContext context, string ns, string owner)
         {
             if (owner != null)
             {
-                var resolver = context.GetService<IXamlTypeResolver>();
-                var result = resolver.Resolve(owner);
+                var result = context.ResolveType(ns, owner);
 
                 if (result == null)
                 {
-                    throw new XamlLoadException($"Could not find type '{owner}'.");
+                    var name = string.IsNullOrEmpty(ns) ? owner : $"{ns}:{owner}";
+                    throw new XamlLoadException($"Could not find type '{name}'.");
                 }
 
                 return result;
@@ -64,19 +73,5 @@ namespace Avalonia.Markup.Xaml.Converters
 
             return null;
         }
-
-        private (string owner, string property) ParseProperty(string s)
-        {
-            var result = regex.Match(s);
-
-            if (result.Groups[1].Success)
-            {
-                return (result.Groups[1].Value, result.Groups[2].Value);
-            }
-            else
-            {
-                return (null, result.Groups[3].Value);
-            }
-        }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs b/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs
index 789f7675be..08ba26573f 100644
--- a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs
@@ -32,185 +32,28 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions
         {
             var descriptorContext = (ITypeDescriptorContext)serviceProvider;
 
-            var pathInfo = ParsePath(Path, descriptorContext);
-            ValidateState(pathInfo);
-
             return new Binding
             {
                 TypeResolver = descriptorContext.ResolveType,
                 Converter = Converter,
                 ConverterParameter = ConverterParameter,
-                ElementName = pathInfo.ElementName ?? ElementName,
+                ElementName = ElementName,
                 FallbackValue = FallbackValue,
                 Mode = Mode,
-                Path = pathInfo.Path,
+                Path = Path,
                 Priority = Priority,
                 Source = Source,
-                RelativeSource = pathInfo.RelativeSource ?? RelativeSource,
+                RelativeSource = RelativeSource,
                 DefaultAnchor = new WeakReference(GetDefaultAnchor((ITypeDescriptorContext)serviceProvider))
             };
         }
 
-        private class PathInfo
-        {
-            public string Path { get; set; }
-            public string ElementName { get; set; }
-            public RelativeSource RelativeSource { get; set; }
-        }
-
-        private void ValidateState(PathInfo pathInfo)
-        {
-            if (pathInfo.ElementName != null && ElementName != null)
-            {
-                throw new InvalidOperationException(
-                    "ElementName property cannot be set when an #elementName path is provided.");
-            }
-
-            if (pathInfo.RelativeSource != null && RelativeSource != null)
-            {
-                throw new InvalidOperationException(
-                    "ElementName property cannot be set when a $self or $parent path is provided.");
-            }
-
-            if ((pathInfo.ElementName != null || ElementName != null) &&
-                (pathInfo.RelativeSource != null || RelativeSource != null))
-            {
-                throw new InvalidOperationException(
-                    "ElementName property cannot be set with a RelativeSource.");
-            }
-        }
-
-        private static PathInfo ParsePath(string path, ITypeDescriptorContext context)
-        {
-            var result = new PathInfo();
-
-            if (string.IsNullOrWhiteSpace(path) || path == ".")
-            {
-                result.Path = string.Empty;
-                return result;
-            }
-            else if (path.StartsWith("!"))
-            {
-                int pathStart = 0;
-                for (; pathStart < path.Length && path[pathStart] == '!'; ++pathStart);
-                result.Path = path.Substring(0, pathStart);
-                path = path.Substring(pathStart);
-            }
-
-            if (path.StartsWith("#"))
-            {
-                var dot = path.IndexOf('.');
-
-                if (dot != -1)
-                {
-                    result.Path += path.Substring(dot + 1);
-                    result.ElementName = path.Substring(1, dot - 1);
-                }
-                else
-                {
-                    result.Path += string.Empty;
-                    result.ElementName = path.Substring(1);
-                }
-            }
-            else if (path.StartsWith("$"))
-            {
-                var relativeSource = new RelativeSource
-                {
-                    Tree = TreeType.Logical
-                };
-                result.RelativeSource = relativeSource;
-                var dot = path.IndexOf('.');
-                string relativeSourceMode;
-                if (dot != -1)
-                {
-                    result.Path += path.Substring(dot + 1);
-                    relativeSourceMode = path.Substring(1, dot - 1);
-                }
-                else
-                {
-                    result.Path += string.Empty;
-                    relativeSourceMode = path.Substring(1);
-                }
-
-                if (relativeSourceMode == "self")
-                {
-                    relativeSource.Mode = RelativeSourceMode.Self;
-                }
-                else if (relativeSourceMode == "parent")
-                {
-                    relativeSource.Mode = RelativeSourceMode.FindAncestor;
-                    relativeSource.AncestorLevel = 1;
-                }
-                else if (relativeSourceMode.StartsWith("parent["))
-                {
-                    relativeSource.Mode = RelativeSourceMode.FindAncestor;
-                    var parentConfigStart = relativeSourceMode.IndexOf('[');
-                    if (!relativeSourceMode.EndsWith("]"))
-                    {
-                        throw new InvalidOperationException("Invalid RelativeSource binding syntax. Expected matching ']' for '['.");
-                    }
-                    var parentConfigParams = relativeSourceMode.Substring(parentConfigStart + 1).TrimEnd(']').Split(';');
-                    if (parentConfigParams.Length > 2 || parentConfigParams.Length == 0)
-                    {
-                        throw new InvalidOperationException("Expected either 1 or 2 parameters for RelativeSource binding syntax");
-                    }
-                    else if (parentConfigParams.Length == 1)
-                    {
-                        if (int.TryParse(parentConfigParams[0], out int level))
-                        {
-                            relativeSource.AncestorType = null;
-                            relativeSource.AncestorLevel = level + 1;
-                        }
-                        else
-                        {
-                            relativeSource.AncestorType = LookupAncestorType(parentConfigParams[0], context);
-                        }
-                    }
-                    else
-                    {
-                        relativeSource.AncestorType = LookupAncestorType(parentConfigParams[0], context);
-                        relativeSource.AncestorLevel = int.Parse(parentConfigParams[1]) + 1;
-                    }
-                }
-                else
-                {
-                    throw new InvalidOperationException($"Invalid RelativeSource binding syntax: {relativeSourceMode}");
-                }
-            }
-            else
-            {
-                result.Path += path;
-            }
-
-            return result;
-        }
-
-        private static Type LookupAncestorType(string ancestorTypeName, ITypeDescriptorContext context)
-        {
-            var parts = ancestorTypeName.Split(':');
-            if (parts.Length == 0 || parts.Length > 2)
-            {
-                throw new InvalidOperationException("Invalid type name");
-            }
-
-            if (parts.Length == 1)
-            {
-                return context.ResolveType(string.Empty, parts[0]);
-            }
-            else
-            {
-                return context.ResolveType(parts[0], parts[1]);
-            }
-        }
-
         private static object GetDefaultAnchor(ITypeDescriptorContext context)
         {
-            object anchor = null;
-
-            // The target is not a control, so we need to find an anchor that will let us look
+            // If the target is not a control, so we need to find an anchor that will let us look
             // up named controls and style resources. First look for the closest IControl in
             // the context.
-            anchor = context.GetFirstAmbientValue<IControl>();
+            object anchor = context.GetFirstAmbientValue<IControl>();
 
             // If a control was not found, then try to find the highest-level style as the XAML
             // file could be a XAML file containing only styles.
diff --git a/src/Markup/Avalonia.Markup.Xaml/Parsers/PropertyParser.cs b/src/Markup/Avalonia.Markup.Xaml/Parsers/PropertyParser.cs
new file mode 100644
index 0000000000..702758efae
--- /dev/null
+++ b/src/Markup/Avalonia.Markup.Xaml/Parsers/PropertyParser.cs
@@ -0,0 +1,85 @@
+using System;
+using Avalonia.Data.Core;
+using Avalonia.Markup.Parsers;
+using Avalonia.Utilities;
+
+namespace Avalonia.Markup.Xaml.Parsers
+{
+    internal class PropertyParser
+    {
+        public (string ns, string owner, string name) Parse(CharacterReader r)
+        {
+            if (r.End)
+            {
+                throw new ExpressionParseException(0, "Expected property name.");
+            }
+
+            var openParens = r.TakeIf('(');
+            bool closeParens = false;
+            string ns = null;
+            string owner = null;
+            string name = null;
+
+            do
+            {
+                var token = IdentifierParser.Parse(r);
+
+                if (token == null)
+                {
+                    if (r.End)
+                    {
+                        break;
+                    }
+                    else
+                    {
+                        if (openParens && !r.End && (closeParens = r.TakeIf(')')))
+                        {
+                            break;
+                        }
+                        else if (openParens)
+                        {
+                            throw new ExpressionParseException(r.Position, $"Expected ')'.");
+                        }
+
+                        throw new ExpressionParseException(r.Position, $"Unexpected '{r.Peek}'.");
+                    }
+                }
+                else if (!r.End && r.TakeIf(':'))
+                {
+                    ns = ns == null ?
+                        token :
+                        throw new ExpressionParseException(r.Position, "Unexpected ':'.");
+                }
+                else if (!r.End && r.TakeIf('.'))
+                {
+                    owner = owner == null ?
+                        token :
+                        throw new ExpressionParseException(r.Position, "Unexpected '.'.");
+                }
+                else
+                {
+                    name = token;
+                }
+            } while (!r.End);
+
+            if (name == null)
+            {
+                throw new ExpressionParseException(0, "Expected property name.");
+            }
+            else if (openParens && owner == null)
+            {
+                throw new ExpressionParseException(1, "Expected property owner.");
+            }
+            else if (openParens && !closeParens)
+            {
+                throw new ExpressionParseException(r.Position, "Expected ')'.");
+            }
+            else if (!r.End)
+            {
+                throw new ExpressionParseException(r.Position, "Expected end of expression.");
+            }
+
+            return (ns, owner, name);
+        }
+    }
+}
diff --git a/src/Markup/Avalonia.Markup.Xaml/PortableXaml/AvaloniaRuntimeTypeProvider.cs b/src/Markup/Avalonia.Markup.Xaml/PortableXaml/AvaloniaRuntimeTypeProvider.cs
index 3933a6ff19..cdb5fc3416 100644
--- a/src/Markup/Avalonia.Markup.Xaml/PortableXaml/AvaloniaRuntimeTypeProvider.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/PortableXaml/AvaloniaRuntimeTypeProvider.cs
@@ -7,7 +7,6 @@ using System.Linq;
 using System.Reflection;
 using Avalonia.Controls;
 using Avalonia.Data;
-using Avalonia.Markup.Data;
 using Avalonia.Markup.Xaml.Templates;
 using Avalonia.Media;
 using Avalonia.Metadata;
@@ -33,6 +32,7 @@ namespace Avalonia.Markup.Xaml.Context
         private static readonly IEnumerable<Assembly> ForcedAssemblies = new[]
         {
             typeof(AvaloniaObject).GetTypeInfo().Assembly,
+            typeof(Animation.Animation).GetTypeInfo().Assembly,
             typeof(Control).GetTypeInfo().Assembly,
             typeof(Style).GetTypeInfo().Assembly,
             typeof(DataTemplate).GetTypeInfo().Assembly,
@@ -146,4 +146,4 @@ namespace Avalonia.Markup.Xaml.Context
             return null;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Markup/Avalonia.Markup/Data/Binding.cs b/src/Markup/Avalonia.Markup/Data/Binding.cs
index e5f7ea1742..03678c3b5a 100644
--- a/src/Markup/Avalonia.Markup/Data/Binding.cs
+++ b/src/Markup/Avalonia.Markup/Data/Binding.cs
@@ -105,34 +105,53 @@ namespace Avalonia.Data
             
             ExpressionObserver observer;
 
+            var (node, mode)  = ExpressionObserverBuilder.Parse(Path, enableDataValidation, TypeResolver);
+
             if (ElementName != null)
             {
                 observer = CreateElementObserver(
                     (target as IStyledElement) ?? (anchor as IStyledElement),
                     ElementName,
-                    Path,
-                    enableDataValidation);
+                    node);
             }
             else if (Source != null)
             {
-                observer = CreateSourceObserver(Source, Path, enableDataValidation);
+                observer = CreateSourceObserver(Source, node);
+            }
+            else if (RelativeSource == null)
+            {
+                if (mode == SourceMode.Data)
+                {
+                    observer = CreateDataContextObserver(
+                        target,
+                        node,
+                        targetProperty == StyledElement.DataContextProperty,
+                        anchor); 
+                }
+                else
+                {
+                    observer = new ExpressionObserver(
+                        (target as IStyledElement) ?? (anchor as IStyledElement),
+                        node);
+                }
             }
-            else if (RelativeSource == null || RelativeSource.Mode == RelativeSourceMode.DataContext)
+            else if (RelativeSource.Mode == RelativeSourceMode.DataContext)
             {
                 observer = CreateDataContextObserver(
                     target,
-                    Path,
+                    node,
                     targetProperty == StyledElement.DataContextProperty,
-                    anchor,
-                    enableDataValidation);
+                    anchor);
             }
             else if (RelativeSource.Mode == RelativeSourceMode.Self)
             {
-                observer = CreateSourceObserver(target, Path, enableDataValidation);
+                observer = CreateSourceObserver(target, node);
             }
             else if (RelativeSource.Mode == RelativeSourceMode.TemplatedParent)
             {
-                observer = CreateTemplatedParentObserver(target, Path, enableDataValidation);
+                observer = CreateTemplatedParentObserver(
+                    (target as IStyledElement) ?? (anchor as IStyledElement),
+                    node);
             }
             else if (RelativeSource.Mode == RelativeSourceMode.FindAncestor)
             {
@@ -144,8 +163,7 @@ namespace Avalonia.Data
                 observer = CreateFindAncestorObserver(
                     (target as IStyledElement) ?? (anchor as IStyledElement),
                     RelativeSource,
-                    Path,
-                    enableDataValidation);
+                    node);
             }
             else
             {
@@ -176,10 +194,9 @@ namespace Avalonia.Data
 
         private ExpressionObserver CreateDataContextObserver(
             IAvaloniaObject target,
-            string path,
+            ExpressionNode node,
             bool targetIsDataContext,
-            object anchor,
-            bool enableDataValidation)
+            object anchor)
         {
             Contract.Requires<ArgumentNullException>(target != null);
 
@@ -195,48 +212,41 @@ namespace Avalonia.Data
 
             if (!targetIsDataContext)
             {
-                var result = ExpressionObserverBuilder.Build(
+                var result = new ExpressionObserver(
                     () => target.GetValue(StyledElement.DataContextProperty),
-                    path,
+                    node,
                     new UpdateSignal(target, StyledElement.DataContextProperty),
-                    enableDataValidation,
-                    typeResolver: TypeResolver);
+                    null);
 
                 return result;
             }
             else
             {
-                return ExpressionObserverBuilder.Build(
+                return new ExpressionObserver(
                     GetParentDataContext(target),
-                    path,
-                    enableDataValidation,
-                    typeResolver: TypeResolver);
+                    node,
+                    null);
             }
         }
 
         private ExpressionObserver CreateElementObserver(
             IStyledElement target,
             string elementName,
-            string path,
-            bool enableDataValidation)
+            ExpressionNode node)
         {
             Contract.Requires<ArgumentNullException>(target != null);
-
-            var description = $"#{elementName}.{path}";
-            var result = ExpressionObserverBuilder.Build(
+            
+            var result = new ExpressionObserver(
                 ControlLocator.Track(target, elementName),
-                path,
-                enableDataValidation,
-                description,
-                typeResolver: TypeResolver);
+                node,
+                null);
             return result;
         }
 
         private ExpressionObserver CreateFindAncestorObserver(
             IStyledElement target,
             RelativeSource relativeSource,
-            string path,
-            bool enableDataValidation)
+            ExpressionNode node)
         {
             Contract.Requires<ArgumentNullException>(target != null);
 
@@ -260,36 +270,32 @@ namespace Avalonia.Data
                     throw new InvalidOperationException("Invalid tree to traverse.");
             }
 
-            return ExpressionObserverBuilder.Build(
+            return new ExpressionObserver(
                 controlLocator,
-                path,
-                enableDataValidation,
-                typeResolver: TypeResolver);
+                node,
+                null);
         }
 
         private ExpressionObserver CreateSourceObserver(
             object source,
-            string path,
-            bool enableDataValidation)
+            ExpressionNode node)
         {
             Contract.Requires<ArgumentNullException>(source != null);
 
-            return ExpressionObserverBuilder.Build(source, path, enableDataValidation, typeResolver: TypeResolver);
+            return new ExpressionObserver(source, node);
         }
 
         private ExpressionObserver CreateTemplatedParentObserver(
             IAvaloniaObject target,
-            string path,
-            bool enableDataValidation)
+            ExpressionNode node)
         {
             Contract.Requires<ArgumentNullException>(target != null);
             
-            var result = ExpressionObserverBuilder.Build(
+            var result = new ExpressionObserver(
                 () => target.GetValue(StyledElement.TemplatedParentProperty),
-                path,
+                node,
                 new UpdateSignal(target, StyledElement.TemplatedParentProperty),
-                enableDataValidation,
-                typeResolver: TypeResolver);
+                null);
 
             return result;
         }
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/ArgumentListParser.cs b/src/Markup/Avalonia.Markup/Markup/Parsers/ArgumentListParser.cs
index ae48657c01..0ce20e1abf 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/ArgumentListParser.cs
+++ b/src/Markup/Avalonia.Markup/Markup/Parsers/ArgumentListParser.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using Avalonia.Data.Core;
+using Avalonia.Utilities;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -10,7 +11,7 @@ namespace Avalonia.Markup.Parsers
 {
     internal static class ArgumentListParser
     {
-        public static IList<string> Parse(Reader r, char open, char close)
+        public static IList<string> Parse(CharacterReader r, char open, char close, char delimiter = ',')
         {
             if (r.Peek == open)
             {
@@ -21,7 +22,7 @@ namespace Avalonia.Markup.Parsers
                 while (!r.End)
                 {
                     var builder = new StringBuilder();
-                    while (!r.End && r.Peek != ',' && r.Peek != close && !char.IsWhiteSpace(r.Peek))
+                    while (!r.End && r.Peek != delimiter && r.Peek != close && !char.IsWhiteSpace(r.Peek))
                     {
                         builder.Append(r.Take());
                     }
@@ -35,7 +36,7 @@ namespace Avalonia.Markup.Parsers
 
                     if (r.End)
                     {
-                        throw new ExpressionParseException(r.Position, "Expected ','.");
+                        throw new ExpressionParseException(r.Position, $"Expected '{delimiter}'.");
                     }
                     else if (r.TakeIf(close))
                     {
@@ -43,9 +44,9 @@ namespace Avalonia.Markup.Parsers
                     }
                     else
                     {
-                        if (r.Take() != ',')
+                        if (r.Take() != delimiter)
                         {
-                            throw new ExpressionParseException(r.Position, "Expected ','.");
+                            throw new ExpressionParseException(r.Position, $"Expected '{delimiter}'.");
                         }
 
                         r.SkipWhitespace();
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionObserverBuilder.cs b/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionObserverBuilder.cs
index ddbe252fc0..9c98340118 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionObserverBuilder.cs
+++ b/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionObserverBuilder.cs
@@ -1,4 +1,5 @@
 using Avalonia.Data.Core;
+using Avalonia.Utilities;
 using System;
 using System.Collections.Generic;
 using System.Reactive;
@@ -8,14 +9,14 @@ namespace Avalonia.Markup.Parsers
 {
     public static class ExpressionObserverBuilder
     {
-        internal static ExpressionNode Parse(string expression, bool enableValidation = false, Func<string, string, Type> typeResolver = null)
+        internal static (ExpressionNode Node, SourceMode Mode) Parse(string expression, bool enableValidation = false, Func<string, string, Type> typeResolver = null)
         {
             if (string.IsNullOrWhiteSpace(expression))
             {
-                return new EmptyExpressionNode();
+                return (new EmptyExpressionNode(), default);
             }
 
-            var reader = new Reader(expression);
+            var reader = new CharacterReader(expression);
             var parser = new ExpressionParser(enableValidation, typeResolver);
             var node = parser.Parse(reader);
 
@@ -36,7 +37,7 @@ namespace Avalonia.Markup.Parsers
         {
             return new ExpressionObserver(
                 root,
-                Parse(expression, enableDataValidation, typeResolver),
+                Parse(expression, enableDataValidation, typeResolver).Node,
                 description ?? expression);
         }
 
@@ -50,7 +51,7 @@ namespace Avalonia.Markup.Parsers
             Contract.Requires<ArgumentNullException>(rootObservable != null);
             return new ExpressionObserver(
                 rootObservable,
-                Parse(expression, enableDataValidation, typeResolver),
+                Parse(expression, enableDataValidation, typeResolver).Node,
                 description ?? expression);
         }
 
@@ -66,8 +67,8 @@ namespace Avalonia.Markup.Parsers
             Contract.Requires<ArgumentNullException>(rootGetter != null);
 
             return new ExpressionObserver(
-                () => rootGetter(),
-                Parse(expression, enableDataValidation, typeResolver),
+                rootGetter,
+                Parse(expression, enableDataValidation, typeResolver).Node,
                 update,
                 description ?? expression);
         }
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionParser.cs b/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionParser.cs
index 95bb421777..dc1c31ed72 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionParser.cs
+++ b/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionParser.cs
@@ -3,12 +3,19 @@
 
 using Avalonia.Data.Core;
 using Avalonia.Markup.Parsers.Nodes;
+using Avalonia.Utilities;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 
 namespace Avalonia.Markup.Parsers
 {
+    internal enum SourceMode
+    {
+        Data,
+        Control
+    }
+
     internal class ExpressionParser
     {
         private readonly bool _enableValidation;
@@ -20,10 +27,11 @@ namespace Avalonia.Markup.Parsers
             _enableValidation = enableValidation;
         }
 
-        public ExpressionNode Parse(Reader r)
+        public (ExpressionNode Node, SourceMode Mode) Parse(CharacterReader r)
         {
             var nodes = new List<ExpressionNode>();
             var state = State.Start;
+            var mode = SourceMode.Data;
 
             while (!r.End && state != State.End)
             {
@@ -48,6 +56,16 @@ namespace Avalonia.Markup.Parsers
                     case State.Indexer:
                         state = ParseIndexer(r, nodes);
                         break;
+
+                    case State.ElementName:
+                        state = ParseElementName(r, nodes);
+                        mode = SourceMode.Control;
+                        break;
+
+                    case State.RelativeSource:
+                        state = ParseRelativeSource(r, nodes);
+                        mode = SourceMode.Control;
+                        break;
                 }
             }
 
@@ -61,16 +79,24 @@ namespace Avalonia.Markup.Parsers
                 nodes[n].Next = nodes[n + 1];
             }
 
-            return nodes.FirstOrDefault();
+            return (nodes.FirstOrDefault(), mode);
         }
 
-        private State ParseStart(Reader r, IList<ExpressionNode> nodes)
+        private State ParseStart(CharacterReader r, IList<ExpressionNode> nodes)
         {
             if (ParseNot(r))
             {
                 nodes.Add(new LogicalNotNode());
                 return State.Start;
             }
+            else if (ParseSharp(r))
+            {
+                return State.ElementName;
+            }
+            else if (ParseDollarSign(r))
+            {
+                return State.RelativeSource;
+            }
             else if (ParseOpenBrace(r))
             {
                 return State.AttachedProperty;
@@ -93,7 +119,7 @@ namespace Avalonia.Markup.Parsers
             return State.End;
         }
 
-        private static State ParseAfterMember(Reader r, IList<ExpressionNode> nodes)
+        private static State ParseAfterMember(CharacterReader r, IList<ExpressionNode> nodes)
         {
             if (ParseMemberAccessor(r))
             {
@@ -112,7 +138,7 @@ namespace Avalonia.Markup.Parsers
             return State.End;
         }
 
-        private State ParseBeforeMember(Reader r, IList<ExpressionNode> nodes)
+        private State ParseBeforeMember(CharacterReader r, IList<ExpressionNode> nodes)
         {
             if (ParseOpenBrace(r))
             {
@@ -132,21 +158,9 @@ namespace Avalonia.Markup.Parsers
             }
         }
 
-        private State ParseAttachedProperty(Reader r, List<ExpressionNode> nodes)
+        private State ParseAttachedProperty(CharacterReader r, List<ExpressionNode> nodes)
         {
-            string ns = string.Empty;
-            string owner;
-            var ownerOrNamespace = IdentifierParser.Parse(r);
-
-            if (r.TakeIf(':'))
-            {
-                ns = ownerOrNamespace;
-                owner = IdentifierParser.Parse(r);
-            }
-            else
-            {
-                owner = ownerOrNamespace;
-            }
+            var (ns, owner) = ParseTypeName(r);
 
             if (r.End || !r.TakeIf('.'))
             {
@@ -171,7 +185,7 @@ namespace Avalonia.Markup.Parsers
             return State.AfterMember;
         }
 
-        private State ParseIndexer(Reader r, List<ExpressionNode> nodes)
+        private State ParseIndexer(CharacterReader r, List<ExpressionNode> nodes)
         {
             var args = ArgumentListParser.Parse(r, '[', ']');
 
@@ -184,34 +198,128 @@ namespace Avalonia.Markup.Parsers
             return State.AfterMember;
         }
         
-        private static bool ParseNot(Reader r)
+        private State ParseElementName(CharacterReader r, List<ExpressionNode> nodes)
+        {
+            var name = IdentifierParser.Parse(r);
+
+            if (name == null)
+            {
+                throw new ExpressionParseException(r.Position, "Element name expected after '#'.");
+            }
+
+            nodes.Add(new ElementNameNode(name));
+            return State.AfterMember;
+        }
+
+
+        private State ParseRelativeSource(CharacterReader r, List<ExpressionNode> nodes)
+        {
+            var mode = IdentifierParser.Parse(r);
+
+            if (mode == "self")
+            {
+                nodes.Add(new SelfNode());
+            }
+            else if (mode == "parent")
+            {
+                Type ancestorType = null;
+                var ancestorLevel = 0;
+                if (PeekOpenBracket(r))
+                {
+                    var args = ArgumentListParser.Parse(r, '[', ']', ';');
+                    if (args.Count > 2 || args.Count == 0)
+                    {
+                        throw new ExpressionParseException(r.Position, "Too many arguments in RelativeSource syntax sugar");
+                    }
+                    else if (args.Count == 1)
+                    {
+                        if (int.TryParse(args[0], out int level))
+                        {
+                            ancestorType = null;
+                            ancestorLevel = level;
+                        }
+                        else
+                        {
+                            var typeName = ParseTypeName(new CharacterReader(args[0]));
+                            ancestorType = _typeResolver(typeName.ns, typeName.typeName);
+                        }
+                    }
+                    else
+                    {
+                        var typeName = ParseTypeName(new CharacterReader(args[0]));
+                        ancestorType = _typeResolver(typeName.ns, typeName.typeName);
+                        ancestorLevel = int.Parse(args[1]);
+                    }
+                }
+                nodes.Add(new FindAncestorNode(ancestorType, ancestorLevel));
+            }
+            else
+            {
+                throw new ExpressionParseException(r.Position, "Unknown RelativeSource mode.");
+            }
+
+            return State.AfterMember;
+        }
+        
+        private static (string ns, string typeName) ParseTypeName(CharacterReader r)
+        {
+            string ns, typeName;
+            ns = string.Empty;
+            var typeNameOrNamespace = IdentifierParser.Parse(r);
+
+            if (!r.End && r.TakeIf(':'))
+            {
+                ns = typeNameOrNamespace;
+                typeName = IdentifierParser.Parse(r);
+            }
+            else
+            {
+                typeName = typeNameOrNamespace;
+            }
+
+            return (ns, typeName);
+        }
+      
+        private static bool ParseNot(CharacterReader r)
         {
             return !r.End && r.TakeIf('!');
         }
 
-        private static bool ParseMemberAccessor(Reader r)
+        private static bool ParseMemberAccessor(CharacterReader r)
         {
             return !r.End && r.TakeIf('.');
         }
 
-        private static bool ParseOpenBrace(Reader r)
+        private static bool ParseOpenBrace(CharacterReader r)
         {
             return !r.End && r.TakeIf('(');
         }
 
-        private static bool PeekOpenBracket(Reader r)
+        private static bool PeekOpenBracket(CharacterReader r)
         {
             return !r.End && r.Peek == '[';
         }
 
-        private static bool ParseStreamOperator(Reader r)
+        private static bool ParseStreamOperator(CharacterReader r)
         {
             return !r.End && r.TakeIf('^');
         }
 
+        private static bool ParseDollarSign(CharacterReader r)
+        {
+            return !r.End && r.TakeIf('$');
+        }
+
+        private static bool ParseSharp(CharacterReader r)
+        {
+            return !r.End && r.TakeIf('#');
+        }
+
         private enum State
         {
             Start,
+            RelativeSource,
+            ElementName,
             AfterMember,
             BeforeMember,
             AttachedProperty,
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/Nodes/ElementNameNode.cs b/src/Markup/Avalonia.Markup/Markup/Parsers/Nodes/ElementNameNode.cs
new file mode 100644
index 0000000000..bd70c1b222
--- /dev/null
+++ b/src/Markup/Avalonia.Markup/Markup/Parsers/Nodes/ElementNameNode.cs
@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Avalonia.Data.Core;
+using Avalonia.LogicalTree;
+
+namespace Avalonia.Markup.Parsers.Nodes
+{
+    internal class ElementNameNode : ExpressionNode
+    {
+        private readonly string _name;
+        private IDisposable _subscription;
+
+        public ElementNameNode(string name)
+        {
+            _name = name;
+        }
+
+        public override string Description => $"#{_name}";
+
+        protected override void StartListeningCore(WeakReference reference)
+        {
+            if (reference.Target is ILogical logical)
+            {
+                _subscription = ControlLocator.Track(logical, _name).Subscribe(ValueChanged);
+            }
+            else
+            {
+                _subscription = null;
+            }
+        }
+
+        protected override void StopListeningCore()
+        {
+            _subscription?.Dispose();
+            _subscription = null;
+        }
+    }
+}
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/Nodes/FindAncestorNode.cs b/src/Markup/Avalonia.Markup/Markup/Parsers/Nodes/FindAncestorNode.cs
new file mode 100644
index 0000000000..6a5f5a5751
--- /dev/null
+++ b/src/Markup/Avalonia.Markup/Markup/Parsers/Nodes/FindAncestorNode.cs
@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Avalonia.Data.Core;
+using Avalonia.LogicalTree;
+
+namespace Avalonia.Markup.Parsers.Nodes
+{
+    internal class FindAncestorNode : ExpressionNode
+    {
+        private readonly int _level;
+        private readonly Type _ancestorType;
+        private IDisposable _subscription;
+
+        public FindAncestorNode(Type ancestorType, int level)
+        {
+            _level = level;
+            _ancestorType = ancestorType;
+        }
+
+        public override string Description
+        {
+            get
+            {
+                if (_ancestorType == null)
+                {
+                    return $"$parent[{_level}]";
+                }
+                else
+                {
+                    return $"$parent[{_ancestorType.Name}, {_level}]";
+                }
+            }
+        }
+
+        protected override void StartListeningCore(WeakReference reference)
+        {
+            if (reference.Target is ILogical logical)
+            {
+                _subscription = ControlLocator.Track(logical, _level, _ancestorType).Subscribe(ValueChanged);
+            }
+            else
+            {
+                _subscription = null;
+            }
+        }
+
+        protected override void StopListeningCore()
+        {
+            _subscription?.Dispose();
+            _subscription = null;
+        }
+    }
+}
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/Nodes/SelfNode.cs b/src/Markup/Avalonia.Markup/Markup/Parsers/Nodes/SelfNode.cs
new file mode 100644
index 0000000000..88163eda44
--- /dev/null
+++ b/src/Markup/Avalonia.Markup/Markup/Parsers/Nodes/SelfNode.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Avalonia.Data.Core;
+
+namespace Avalonia.Markup.Parsers.Nodes
+{
+    internal class SelfNode : ExpressionNode
+    {
+        public override string Description => "$self";
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaPropertyRegistryTests.cs b/tests/Avalonia.Base.UnitTests/AvaloniaPropertyRegistryTests.cs
index 8b2e500d37..c34e26ac5c 100644
--- a/tests/Avalonia.Base.UnitTests/AvaloniaPropertyRegistryTests.cs
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaPropertyRegistryTests.cs
@@ -99,17 +99,6 @@ namespace Avalonia.Base.UnitTests
             Assert.Null(result);
         }
 
-        [Fact]
-        public void FindRegisteredAttached_Finds_Property()
-        {
-            var result = AvaloniaPropertyRegistry.Instance.FindRegisteredAttached(
-                typeof(Class1),
-                typeof(AttachedOwner),
-                "Attached");
-
-            Assert.Equal(AttachedOwner.AttachedProperty, result);
-        }
-
         private class Class1 : AvaloniaObject
         {
             public static readonly StyledProperty<string> FooProperty =
diff --git a/tests/Avalonia.Markup.UnitTests/Parsers/ExpressionNodeBuilderTests.cs b/tests/Avalonia.Markup.UnitTests/Parsers/ExpressionNodeBuilderTests.cs
index 212b16965c..2d687ff4f7 100644
--- a/tests/Avalonia.Markup.UnitTests/Parsers/ExpressionNodeBuilderTests.cs
+++ b/tests/Avalonia.Markup.UnitTests/Parsers/ExpressionNodeBuilderTests.cs
@@ -162,8 +162,9 @@ namespace Avalonia.Markup.UnitTests.Parsers
             Assert.Equal(e.Arguments.ToArray(), args);
         }
 
-        private List<ExpressionNode> ToList(ExpressionNode node)
+        private List<ExpressionNode> ToList((ExpressionNode node, SourceMode mode) parsed)
         {
+            var (node, _) = parsed;
             var result = new List<ExpressionNode>();
             
             while (node != null)
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Converters/AvaloniaPropertyConverterTest.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Converters/AvaloniaPropertyConverterTest.cs
index a028e246a4..f6f56231bc 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Converters/AvaloniaPropertyConverterTest.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Converters/AvaloniaPropertyConverterTest.cs
@@ -10,6 +10,7 @@ using Xunit;
 using System.ComponentModel;
 using Portable.Xaml;
 using Portable.Xaml.Markup;
+using Avalonia.Controls;
 
 namespace Avalonia.Markup.Xaml.UnitTests.Converters
 {
@@ -26,7 +27,8 @@ namespace Avalonia.Markup.Xaml.UnitTests.Converters
         public void ConvertFrom_Finds_Fully_Qualified_Property()
         {
             var target = new AvaloniaPropertyTypeConverter();
-            var context = CreateContext();
+            var style = new Style(x => x.OfType<Class1>());
+            var context = CreateContext(style);
             var result = target.ConvertFrom(context, null, "Class1.Foo");
 
             Assert.Equal(Class1.FooProperty, result);
@@ -47,7 +49,8 @@ namespace Avalonia.Markup.Xaml.UnitTests.Converters
         public void ConvertFrom_Finds_Attached_Property()
         {
             var target = new AvaloniaPropertyTypeConverter();
-            var context = CreateContext();
+            var style = new Style(x => x.OfType<Class1>());
+            var context = CreateContext(style);
             var result = target.ConvertFrom(context, null, "AttachedOwner.Attached");
 
             Assert.Equal(AttachedOwner.AttachedProperty, result);
@@ -57,12 +60,37 @@ namespace Avalonia.Markup.Xaml.UnitTests.Converters
         public void ConvertFrom_Finds_Attached_Property_With_Parentheses()
         {
             var target = new AvaloniaPropertyTypeConverter();
-            var context = CreateContext();
+            var style = new Style(x => x.OfType<Class1>());
+            var context = CreateContext(style);
             var result = target.ConvertFrom(context, null, "(AttachedOwner.Attached)");
 
             Assert.Equal(AttachedOwner.AttachedProperty, result);
         }
 
+        [Fact]
+        public void ConvertFrom_Throws_For_Nonexistent_Property()
+        {
+            var target = new AvaloniaPropertyTypeConverter();
+            var style = new Style(x => x.OfType<Class1>());
+            var context = CreateContext(style);
+
+            var ex = Assert.Throws<XamlLoadException>(() => target.ConvertFrom(context, null, "Nonexistent"));
+
+            Assert.Equal("Could not find property 'Class1.Nonexistent'.", ex.Message);
+        }
+
+        [Fact]
+        public void ConvertFrom_Throws_For_Nonexistent_Attached_Property()
+        {
+            var target = new AvaloniaPropertyTypeConverter();
+            var style = new Style(x => x.OfType<Class1>());
+            var context = CreateContext(style);
+
+            var ex = Assert.Throws<XamlLoadException>(() => target.ConvertFrom(context, null, "AttachedOwner.NonExistent"));
+
+            Assert.Equal("Could not find property 'AttachedOwner.NonExistent'.", ex.Message);
+        }
+
         private ITypeDescriptorContext CreateContext(Style style = null)
         {
             var tdMock = new Mock<ITypeDescriptorContext>();
@@ -126,4 +154,4 @@ namespace Avalonia.Markup.Xaml.UnitTests.Converters
                 AvaloniaProperty.RegisterAttached<AttachedOwner, Class1, string>("Attached");
         }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Parsers/PropertyParserTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Parsers/PropertyParserTests.cs
new file mode 100644
index 0000000000..cae6449722
--- /dev/null
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Parsers/PropertyParserTests.cs
@@ -0,0 +1,226 @@
+using System;
+using Avalonia.Data.Core;
+using Avalonia.Markup.Parsers;
+using Avalonia.Markup.Xaml.Parsers;
+using Avalonia.Utilities;
+using Xunit;
+
+namespace Avalonia.Markup.Xaml.UnitTests.Parsers
+{
+    public class PropertyParserTests
+    {
+        [Fact]
+        public void Parses_Name()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("Foo");
+            var (ns, owner, name) = target.Parse(reader);
+
+            Assert.Null(ns);
+            Assert.Null(owner);
+            Assert.Equal("Foo", name);
+        }
+
+        [Fact]
+        public void Parses_Owner_And_Name()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("Foo.Bar");
+            var (ns, owner, name) = target.Parse(reader);
+
+            Assert.Null(ns);
+            Assert.Equal("Foo", owner);
+            Assert.Equal("Bar", name);
+        }
+
+        [Fact]
+        public void Parses_Namespace_Owner_And_Name()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("foo:Bar.Baz");
+            var (ns, owner, name) = target.Parse(reader);
+
+            Assert.Equal("foo", ns);
+            Assert.Equal("Bar", owner);
+            Assert.Equal("Baz", name);
+        }
+
+        [Fact]
+        public void Parses_Owner_And_Name_With_Parentheses()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("(Foo.Bar)");
+            var (ns, owner, name) = target.Parse(reader);
+
+            Assert.Null(ns);
+            Assert.Equal("Foo", owner);
+            Assert.Equal("Bar", name);
+        }
+
+        [Fact]
+        public void Parses_Namespace_Owner_And_Name_With_Parentheses()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("(foo:Bar.Baz)");
+            var (ns, owner, name) = target.Parse(reader);
+
+            Assert.Equal("foo", ns);
+            Assert.Equal("Bar", owner);
+            Assert.Equal("Baz", name);
+        }
+
+        [Fact]
+        public void Fails_With_Empty_String()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(0, ex.Column);
+            Assert.Equal("Expected property name.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Only_Whitespace()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("  ");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(0, ex.Column);
+            Assert.Equal("Unexpected ' '.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Leading_Whitespace()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader(" Foo");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(0, ex.Column);
+            Assert.Equal("Unexpected ' '.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Trailing_Whitespace()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("Foo ");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(3, ex.Column);
+            Assert.Equal("Unexpected ' '.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Invalid_Property_Name()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("123");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(0, ex.Column);
+            Assert.Equal("Unexpected '1'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Trailing_Junk()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("Foo%");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(3, ex.Column);
+            Assert.Equal("Unexpected '%'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Invalid_Property_Name_After_Owner()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("Foo.123");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(4, ex.Column);
+            Assert.Equal("Unexpected '1'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Whitespace_Between_Owner_And_Name()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("Foo. Bar");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(4, ex.Column);
+            Assert.Equal("Unexpected ' '.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Too_Many_Segments()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("Foo.Bar.Baz");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(8, ex.Column);
+            Assert.Equal("Unexpected '.'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Too_Many_Namespaces()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("foo:bar:Baz");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(8, ex.Column);
+            Assert.Equal("Unexpected ':'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Parens_But_No_Owner()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("(Foo)");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(1, ex.Column);
+            Assert.Equal("Expected property owner.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Parens_And_Namespace_But_No_Owner()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("(foo:Bar)");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(1, ex.Column);
+            Assert.Equal("Expected property owner.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Missing_Close_Parens()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("(Foo.Bar");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(8, ex.Column);
+            Assert.Equal("Expected ')'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Unexpected_Close_Parens()
+        {
+            var target = new PropertyParser();
+            var reader = new CharacterReader("Foo.Bar)");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(7, ex.Column);
+            Assert.Equal("Unexpected ')'.", ex.Message);
+        }
+    }
+}
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs
index 568c6482f5..f327e9ccf2 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs
@@ -281,5 +281,32 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
                 Assert.Equal(5.6, AttachedPropertyOwner.GetDouble(textBlock));
             }
         }
+
+        [Fact]
+        public void Binding_To_Attached_Property_In_Style_Works()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.Xaml;assembly=Avalonia.Markup.Xaml.UnitTests'>
+    <Window.Styles>
+        <Style Selector='TextBlock'>
+            <Setter Property='local:TestControl.Double' Value='{Binding}'/>
+        </Style>
+    </Window.Styles>
+    <TextBlock/>
+</Window>";
+                var loader = new AvaloniaXamlLoader();
+                var window = (Window)loader.Load(xaml);
+                var textBlock = (TextBlock)window.Content;
+
+                window.DataContext = 5.6;
+                window.ApplyTemplate();
+
+                Assert.Equal(5.6, AttachedPropertyOwner.GetDouble(textBlock));
+            }
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
index 2c7e850fee..beaf7477d0 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
@@ -7,6 +7,7 @@ using Avalonia.Markup.Xaml.Styling;
 using Avalonia.Media;
 using Avalonia.Styling;
 using Avalonia.UnitTests;
+using Portable.Xaml;
 using Xunit;
 
 namespace Avalonia.Markup.Xaml.UnitTests.Xaml
@@ -146,5 +147,56 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
                 Assert.NotNull(target.FocusAdorner);
             }
         }
+
+        [Fact]
+        public void Setter_Can_Set_Attached_Property()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.Xaml;assembly=Avalonia.Markup.Xaml.UnitTests'>
+    <Window.Styles>
+        <Style Selector='TextBlock'>
+            <Setter Property='DockPanel.Dock' Value='Right'/>
+        </Style>
+    </Window.Styles>
+    <TextBlock/>
+</Window>";
+                var loader = new AvaloniaXamlLoader();
+                var window = (Window)loader.Load(xaml);
+                var textBlock = (TextBlock)window.Content;
+
+                window.ApplyTemplate();
+
+                Assert.Equal(Dock.Right, DockPanel.GetDock(textBlock));
+            }
+        }
+
+        [Fact(Skip = "The animation system currently needs to be able to set any property on any object")]
+        public void Disallows_Setting_Non_Registered_Property()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.Xaml;assembly=Avalonia.Markup.Xaml.UnitTests'>
+    <Window.Styles>
+        <Style Selector='TextBlock'>
+            <Setter Property='Button.IsDefault' Value='True'/>
+        </Style>
+    </Window.Styles>
+    <TextBlock/>
+</Window>";
+                var loader = new AvaloniaXamlLoader();
+                var ex = Assert.Throws<XamlObjectWriterException>(() => loader.Load(xaml));
+
+                Assert.Equal(
+                    "Property 'Button.IsDefault' is not registered on 'Avalonia.Controls.TextBlock'.",
+                    ex.InnerException.Message);
+            }
+        }
     }
-}
\ No newline at end of file
+}