public class ProgressionViewModel : IBindingContext
{
 [Observable] private readonly IProperty<int> _task = new Property<int>(69);
}

<ui:UXML xmlns:uitk="UnityMvvmToolkit.UITK.BindableUIElements" ...>
 <uitk:BindingContextProvider name="BindingContextProvider">
 <uitk:BindableLabel binding-text-path="Task" />
 </uitk:BindingContextProvider>
</ui:UXML>

public class PlayerProgressViewModel : IBindingContext, IDisposable
{
 [Observable] private readonly IProperty<string> _age;
 [Observable] private readonly IProperty<string> _days;
 private readonly IPlayerLifeCycleService _playerLifeCycleService;
 public PlayerProgressViewModel(IPlayerLifeCycleService playerLifeCycleService)
 {
 _playerLifeCycleService = playerLifeCycleService;
 _playerLifeCycleService.AgeChanged += OnAgeChanged;
 _playerLifeCycleService.DaysChanged += OnDaysChanged;
 _age = new Property<string>(GetAgeString(playerLifeCycleService.Age));
 _days = new Property<string>(GetDaysString(playerLifeCycleService.Days));
 }
 public void Dispose()
 {
 _playerLifeCycleService.AgeChanged -= OnAgeChanged;
 _playerLifeCycleService.DaysChanged -= OnDaysChanged;
 }
 private void OnAgeChanged(object sender, int age)
 {
 _age.Value = GetAgeString(age);
 }
 private void OnDaysChanged(object sender, int days)
 {
 _days.Value = GetDaysString(days);
 }
 private static string GetAgeString(int age)
 {
 return $"Age: {age}";
 }
 private static string GetDaysString(int days)
 {
 return $"Days: {days}";
 }
}

<ui:UXML ui:UXML xmlns:uitk="UnityMvvmToolkit.UITK.BindableUIElements" ...>
 <uitk:BindingContextProvider name="BindingContextProvider">
 <uitk:BindableLabel binding-text-path="Age" />
 <uitk:BindableLabel binding-text-path="Days" />
 </uitk:BindingContextProvider>
</ui:UXML>

public class MainScreenViewModel : IBindingContext
{
 [Observable] private readonly IReadOnlyProperty<ProgressionViewModel> _progression;
 [Observable] private readonly IReadOnlyProperty<PlayerProgressViewModel> _playerProgress;
 public MainScreenViewModel(PlayerProgressViewModel playerProgressViewModel,
 ProgressionViewModel progressionViewModel)
 {
 _progression = new ReadOnlyProperty<ProgressionViewModel>(progressionViewModel);
 _playerProgress = new ReadOnlyProperty<PlayerProgressViewModel>(playerProgressViewModel);
 }
}

public class MainScreenView : BaseView<MainScreenViewModel>
{
}

public abstract class BaseView<TBindingContext> : DocumentView<TBindingContext>
 where TBindingContext : class, IBindingContext
{
 private TBindingContext _bindingContext;
 private IValueConverter[] _valueConverters;
 [Inject]
 public void Construct(TBindingContext bindingContext, IValueConverter[] valueConverters)
 {
 _bindingContext = bindingContext;
 // You can inject the valueConverters array to avoid memory allocations instead of "IEnumerable<IValueConverter>".
 _valueConverters = valueConverters;
 }
 protected override TBindingContext GetBindingContext()
 {
 return _bindingContext;
 }
 protected override IValueConverter[] GetValueConverters()
 {
 return _valueConverters;
 }
 // Returning null is bad practice.
 // You don't need to override this method if you are not using CollectionItemTemplates.
 //
 // protected override IReadOnlyDictionary<Type, object> GetCollectionItemTemplates()
 // {
 // return null;
 // }
}

<ui:UXML ...>
 <ui:Template name="ProgressionView" ... />
 <ui:Instance template="ProgressionView" name="ProgressionView">
 <AttributeOverrides element-name="BindingContextProvider" binding-context-path="Progression" />
 </ui:Instance>
 <ui:Template name="PlayerProgressView" ... />
 <ui:Instance template="PlayerProgressView" name="PlayerProgressView">
 <AttributeOverrides element-name="BindingContextProvider" binding-context-path="PlayerProgress" />
 </ui:Instance>
</ui:UXML>

public interface IPlayerLifeCycleService
{
 int Age { get; }
 int Days { get; }
 event EventHandler<int> AgeChanged;
 event EventHandler<int> DaysChanged;
}

public class PlayerLifeCycleService : IPlayerLifeCycleService, ITickable
{
 private const float DelaySec = 1.0f;
 private int _age;
 private int _days;
 private float _elapsed;
 public int Age
 {
 get => _age;
 private set
 {
 _age = value;
 AgeChanged?.Invoke(this, value);
 }
 }
 public int Days
 {
 get => _days;
 private set
 {
 _days = value;
 DaysChanged?.Invoke(this, value);
 }
 }
 public event EventHandler<int> AgeChanged;
 public event EventHandler<int> DaysChanged;
 public void Tick()
 {
 _elapsed += Time.deltaTime;
 if (_elapsed < DelaySec)
 {
 return;
 }
 _elapsed = 0.0f;
 Age++;
 Days++;
 }
}

public class AppContext : MonoInstaller
{
 public override void InstallBindings()
 {
 InstallValueConverters();
 Container.Bind<MainScreenViewModel>().AsSingle();
 Container.BindInterfacesAndSelfTo<ProgressionViewModel>().AsSingle();
 Container.BindInterfacesAndSelfTo<PlayerProgressViewModel>().AsSingle();
 Container.BindInterfacesTo<PlayerLifeCycleService>().AsSingle();
 }
 private void InstallValueConverters()
 {
 Container
 .Bind<IValueConverter[]>()
 .FromInstance(new IValueConverter[]
 {
 new IntToStrConverter()
 })
 .AsSingle();
 }
}