diff --git a/StabilityMatrix.Avalonia/App.axaml.cs b/StabilityMatrix.Avalonia/App.axaml.cs
index 7f7be2d5f..7a95416c3 100644
--- a/StabilityMatrix.Avalonia/App.axaml.cs
+++ b/StabilityMatrix.Avalonia/App.axaml.cs
@@ -464,7 +464,11 @@ internal static void ConfigurePageViewModels(IServiceCollection services)
                 provider.GetRequiredService<OutputsPageViewModel>(),
                 provider.GetRequiredService<WorkflowsPageViewModel>(),
             },
-            FooterPages = { provider.GetRequiredService<SettingsViewModel>() },
+            FooterPages =
+            {
+                provider.GetRequiredService<DocumentationViewModel>(),
+                provider.GetRequiredService<SettingsViewModel>(),
+            },
         });
     }
 
@@ -838,6 +842,15 @@ internal static IServiceCollection ConfigureServices(bool disableMessagePipeInte
             })
             .AddPolicyHandler(retryPolicy);
 
+        services
+            .AddRefitClient<IGitHubContentApi>(defaultRefitSettings)
+            .ConfigureHttpClient(c =>
+            {
+                c.BaseAddress = new Uri("https://api.github.com");
+                c.Timeout = TimeSpan.FromMinutes(1);
+            })
+            .AddPolicyHandler(retryPolicy);
+
         services
             .AddRefitClient<IHuggingFaceApi>(defaultRefitSettings) // Assuming defaultRefitSettings is suitable
             .ConfigureHttpClient(c =>
diff --git a/StabilityMatrix.Avalonia/Controls/DocumentationMarkdownViewer.cs b/StabilityMatrix.Avalonia/Controls/DocumentationMarkdownViewer.cs
new file mode 100644
index 000000000..8737f53ea
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Controls/DocumentationMarkdownViewer.cs
@@ -0,0 +1,80 @@
+using System;
+using System.Windows.Input;
+using Avalonia;
+using Markdown.Avalonia;
+
+namespace StabilityMatrix.Avalonia.Controls;
+
+/// <summary>
+/// A <see cref="BetterMarkdownScrollViewer"/> that routes hyperlink clicks through a
+/// bindable <see cref="LinkCommand"/> (so relative <c>.md</c> links can navigate in-app
+/// and external links can open in the browser) and resolves relative image paths against
+/// <see cref="ImageBaseUrl"/> via the engine's asset path root.
+/// </summary>
+public class DocumentationMarkdownViewer : BetterMarkdownScrollViewer
+{
+    /// <summary>
+    /// Command invoked when a hyperlink is clicked. The command parameter is the raw href string.
+    /// </summary>
+    public static readonly StyledProperty<ICommand?> LinkCommandProperty = AvaloniaProperty.Register<
+        DocumentationMarkdownViewer,
+        ICommand?
+    >(nameof(LinkCommand));
+
+    /// <summary>
+    /// Base URL used to resolve relative image paths in the rendered markdown
+    /// (e.g. the raw URL of the current page's folder).
+    /// </summary>
+    public static readonly StyledProperty<string?> ImageBaseUrlProperty = AvaloniaProperty.Register<
+        DocumentationMarkdownViewer,
+        string?
+    >(nameof(ImageBaseUrl));
+
+    public ICommand? LinkCommand
+    {
+        get => GetValue(LinkCommandProperty);
+        set => SetValue(LinkCommandProperty, value);
+    }
+
+    public string? ImageBaseUrl
+    {
+        get => GetValue(ImageBaseUrlProperty);
+        set => SetValue(ImageBaseUrlProperty, value);
+    }
+
+    public DocumentationMarkdownViewer()
+    {
+        ApplyLinkCommand();
+        ApplyImageBaseUrl();
+    }
+
+    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+    {
+        base.OnPropertyChanged(change);
+
+        if (change.Property == LinkCommandProperty)
+        {
+            ApplyLinkCommand();
+        }
+        else if (change.Property == ImageBaseUrlProperty)
+        {
+            ApplyImageBaseUrl();
+        }
+    }
+
+    private void ApplyLinkCommand()
+    {
+        // The engine (IMarkdownEngine) owns the HyperlinkCommand used for all rendered links.
+        if (Engine is IMarkdownEngine engine)
+        {
+            engine.HyperlinkCommand = LinkCommand;
+        }
+    }
+
+    private void ApplyImageBaseUrl()
+    {
+        // AssetPathRoot flows through to the engine's bitmap loader so relative image
+        // paths resolve against the raw docs URL.
+        AssetPathRoot = ImageBaseUrl ?? string.Empty;
+    }
+}
diff --git a/StabilityMatrix.Avalonia/ViewModels/Documentation/DocumentationPageNavItem.cs b/StabilityMatrix.Avalonia/ViewModels/Documentation/DocumentationPageNavItem.cs
new file mode 100644
index 000000000..819b1e3b3
--- /dev/null
+++ b/StabilityMatrix.Avalonia/ViewModels/Documentation/DocumentationPageNavItem.cs
@@ -0,0 +1,18 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+
+namespace StabilityMatrix.Avalonia.ViewModels.Documentation;
+
+/// <summary>
+/// A single navigable documentation page entry in the sidebar.
+/// </summary>
+public partial class DocumentationPageNavItem : ObservableObject
+{
+    /// <summary>Display title, e.g. "Overview".</summary>
+    public required string Title { get; init; }
+
+    /// <summary>Path relative to the docs root, e.g. <c>getting-started/overview.md</c>.</summary>
+    public required string Path { get; init; }
+
+    [ObservableProperty]
+    private bool isSelected;
+}
diff --git a/StabilityMatrix.Avalonia/ViewModels/Documentation/DocumentationSectionNavItem.cs b/StabilityMatrix.Avalonia/ViewModels/Documentation/DocumentationSectionNavItem.cs
new file mode 100644
index 000000000..7a44bcf3b
--- /dev/null
+++ b/StabilityMatrix.Avalonia/ViewModels/Documentation/DocumentationSectionNavItem.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+
+namespace StabilityMatrix.Avalonia.ViewModels.Documentation;
+
+/// <summary>
+/// A section grouping in the documentation sidebar (e.g. "Getting Started").
+/// </summary>
+public class DocumentationSectionNavItem
+{
+    /// <summary>Section title. Empty for the root section (renders without a header).</summary>
+    public required string Title { get; init; }
+
+    /// <summary>Whether this section has a visible header (i.e. is not the root section).</summary>
+    public bool HasHeader => !string.IsNullOrEmpty(Title);
+
+    /// <summary>Pages within this section.</summary>
+    public required IReadOnlyList<DocumentationPageNavItem> Pages { get; init; }
+}
diff --git a/StabilityMatrix.Avalonia/ViewModels/DocumentationViewModel.cs b/StabilityMatrix.Avalonia/ViewModels/DocumentationViewModel.cs
new file mode 100644
index 000000000..80a6beab9
--- /dev/null
+++ b/StabilityMatrix.Avalonia/ViewModels/DocumentationViewModel.cs
@@ -0,0 +1,259 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Input;
+using AsyncAwaitBestPractices;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using FluentAvalonia.UI.Controls;
+using FluentIcons.Common;
+using Injectio.Attributes;
+using Microsoft.Extensions.Logging;
+using StabilityMatrix.Avalonia.ViewModels.Base;
+using StabilityMatrix.Avalonia.ViewModels.Documentation;
+using StabilityMatrix.Core.Attributes;
+using StabilityMatrix.Core.Models.Documentation;
+using StabilityMatrix.Core.Processes;
+using StabilityMatrix.Core.Services;
+using Symbol = FluentIcons.Common.Symbol;
+using SymbolIconSource = FluentIcons.Avalonia.Fluent.SymbolIconSource;
+
+namespace StabilityMatrix.Avalonia.ViewModels;
+
+[View(typeof(Views.DocumentationPage))]
+[RegisterSingleton<DocumentationViewModel>]
+public partial class DocumentationViewModel : PageViewModelBase
+{
+    private readonly ILogger<DocumentationViewModel> logger;
+    private readonly IDocumentationService documentationService;
+
+    public override string Title => "Documentation";
+
+    public override IconSource IconSource =>
+        new SymbolIconSource { Symbol = Symbol.BookOpen, IconVariant = IconVariant.Filled };
+
+    public ObservableCollection<DocumentationSectionNavItem> Sections { get; } = [];
+
+    [ObservableProperty]
+    private DocumentationPageNavItem? selectedPage;
+
+    [ObservableProperty]
+    private string? currentMarkdown;
+
+    /// <summary>Raw base URL of the currently displayed page's folder (for relative image resolution).</summary>
+    [ObservableProperty]
+    private string? currentImageBaseUrl;
+
+    [ObservableProperty]
+    private bool isTreeLoading;
+
+    [ObservableProperty]
+    private bool isPageLoading;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasError))]
+    private string? errorMessage;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsContentVisible))]
+    private bool isDocsUnavailable;
+
+    public bool HasError => !string.IsNullOrEmpty(ErrorMessage);
+
+    public bool IsContentVisible => !IsDocsUnavailable;
+
+    /// <summary>Command bound to the markdown viewer to intercept hyperlink clicks.</summary>
+    public ICommand LinkClickedCommand { get; }
+
+    private CancellationTokenSource? pageCts;
+    private bool hasLoadedTree;
+
+    public DocumentationViewModel(
+        ILogger<DocumentationViewModel> logger,
+        IDocumentationService documentationService
+    )
+    {
+        this.logger = logger;
+        this.documentationService = documentationService;
+        LinkClickedCommand = new RelayCommand<string>(OnLinkClicked);
+    }
+
+    public override async Task OnLoadedAsync()
+    {
+        await base.OnLoadedAsync();
+
+        if (!hasLoadedTree)
+        {
+            await LoadTreeAsync();
+        }
+    }
+
+    [RelayCommand]
+    private async Task RetryAsync()
+    {
+        await LoadTreeAsync(forceRefresh: true);
+    }
+
+    [RelayCommand]
+    private void SelectPage(DocumentationPageNavItem? page)
+    {
+        if (page is not null)
+            SelectedPage = page;
+    }
+
+    private async Task LoadTreeAsync(bool forceRefresh = false)
+    {
+        IsTreeLoading = true;
+        ErrorMessage = null;
+        IsDocsUnavailable = false;
+
+        try
+        {
+            var sections = await documentationService.GetSectionsAsync(forceRefresh);
+
+            Sections.Clear();
+            foreach (var section in sections)
+            {
+                Sections.Add(
+                    new DocumentationSectionNavItem
+                    {
+                        Title = section.Title,
+                        Pages = section
+                            .Pages.Select(p => new DocumentationPageNavItem
+                            {
+                                Title = p.Title,
+                                Path = p.Path,
+                            })
+                            .ToList(),
+                    }
+                );
+            }
+
+            hasLoadedTree = true;
+
+            // Select the first available page (docs README landing page comes first).
+            var firstPage = Sections.SelectMany(s => s.Pages).FirstOrDefault();
+            if (firstPage is not null)
+            {
+                SelectedPage = firstPage;
+            }
+        }
+        catch (DocumentationNotAvailableException e)
+        {
+            logger.LogInformation(e, "Documentation is not available yet");
+            IsDocsUnavailable = true;
+            Sections.Clear();
+        }
+        catch (Exception e)
+        {
+            logger.LogWarning(e, "Failed to load documentation tree");
+            ErrorMessage = "Could not load the documentation listing. Check your connection and try again.";
+            Sections.Clear();
+        }
+        finally
+        {
+            IsTreeLoading = false;
+        }
+    }
+
+    partial void OnSelectedPageChanged(DocumentationPageNavItem? oldValue, DocumentationPageNavItem? newValue)
+    {
+        if (oldValue is not null)
+            oldValue.IsSelected = false;
+
+        if (newValue is null)
+            return;
+
+        newValue.IsSelected = true;
+        LoadPageAsync(newValue.Path).SafeFireAndForget();
+    }
+
+    private async Task LoadPageAsync(string docsRelativePath)
+    {
+        // Cancel any in-flight page load
+        await (pageCts?.CancelAsync() ?? Task.CompletedTask);
+        pageCts?.Dispose();
+        pageCts = new CancellationTokenSource();
+        var ct = pageCts.Token;
+
+        IsPageLoading = true;
+        ErrorMessage = null;
+
+        try
+        {
+            var markdown = await documentationService.GetPageMarkdownAsync(
+                docsRelativePath,
+                cancellationToken: ct
+            );
+            ct.ThrowIfCancellationRequested();
+
+            CurrentMarkdown = DocumentationPathResolver.RewriteImageUrls(docsRelativePath, markdown);
+            CurrentImageBaseUrl = GetPageFolderRawUrl(docsRelativePath);
+        }
+        catch (OperationCanceledException)
+        {
+            // Superseded by a newer selection; ignore.
+        }
+        catch (Exception e)
+        {
+            logger.LogWarning(e, "Failed to load documentation page {Path}", docsRelativePath);
+            ErrorMessage = "Could not load this page. Check your connection and try again.";
+            CurrentMarkdown = null;
+        }
+        finally
+        {
+            IsPageLoading = false;
+        }
+    }
+
+    private void OnLinkClicked(string? href)
+    {
+        if (string.IsNullOrWhiteSpace(href))
+            return;
+
+        var currentPath = SelectedPage?.Path ?? "README.md";
+        var resolved = DocumentationPathResolver.ResolveLink(currentPath, href);
+
+        switch (resolved.Kind)
+        {
+            case DocumentationPathResolver.LinkKind.External:
+                ProcessRunner.OpenUrl(resolved.Target);
+                break;
+
+            case DocumentationPathResolver.LinkKind.InternalPage:
+                NavigateToPath(resolved.Target);
+                break;
+
+            case DocumentationPathResolver.LinkKind.Anchor:
+                // In-page anchors are not currently supported; no-op.
+                break;
+        }
+    }
+
+    private void NavigateToPath(string docsRelativePath)
+    {
+        var match = Sections
+            .SelectMany(s => s.Pages)
+            .FirstOrDefault(p => string.Equals(p.Path, docsRelativePath, StringComparison.OrdinalIgnoreCase));
+
+        if (match is not null)
+        {
+            SelectedPage = match;
+        }
+        else
+        {
+            // Not part of the discovered tree (e.g. a page not yet listed) — load it directly.
+            LoadPageAsync(docsRelativePath).SafeFireAndForget();
+        }
+    }
+
+    private static string GetPageFolderRawUrl(string docsRelativePath)
+    {
+        var separatorIndex = docsRelativePath.LastIndexOf('/');
+        var folder = separatorIndex < 0 ? string.Empty : docsRelativePath[..(separatorIndex + 1)];
+        return DocumentationConstants.GetRawUrl($"{DocumentationConstants.DocsRoot}/{folder}");
+    }
+}
diff --git a/StabilityMatrix.Avalonia/Views/DocumentationPage.axaml b/StabilityMatrix.Avalonia/Views/DocumentationPage.axaml
new file mode 100644
index 000000000..aece6fbc0
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Views/DocumentationPage.axaml
@@ -0,0 +1,156 @@
+<controls:UserControlBase
+    x:Class="StabilityMatrix.Avalonia.Views.DocumentationPage"
+    xmlns="https://github.com/avaloniaui"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:controls="clr-namespace:StabilityMatrix.Avalonia.Controls"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:docs="clr-namespace:StabilityMatrix.Avalonia.ViewModels.Documentation"
+    xmlns:fluentAvalonia="clr-namespace:FluentIcons.Avalonia.Fluent;assembly=FluentIcons.Avalonia.Fluent"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:vm="clr-namespace:StabilityMatrix.Avalonia.ViewModels"
+    d:DesignHeight="650"
+    d:DesignWidth="900"
+    x:CompileBindings="True"
+    x:DataType="vm:DocumentationViewModel"
+    mc:Ignorable="d">
+
+    <Grid ColumnDefinitions="280,*">
+
+        <!--  Left pane: navigation tree  -->
+        <Border
+            Grid.Column="0"
+            Background="{DynamicResource CardBackgroundFillColorDefaultBrush}"
+            BorderBrush="{DynamicResource CardStrokeColorDefaultBrush}"
+            BorderThickness="0,0,1,0">
+            <Grid RowDefinitions="Auto,*">
+                <TextBlock
+                    Grid.Row="0"
+                    Margin="16,16,16,8"
+                    FontSize="18"
+                    FontWeight="SemiBold"
+                    Text="Documentation" />
+
+                <!--  Loading tree indicator  -->
+                <controls:ProgressRing
+                    Grid.Row="1"
+                    Width="32"
+                    Height="32"
+                    HorizontalAlignment="Center"
+                    VerticalAlignment="Center"
+                    BorderThickness="4"
+                    IsIndeterminate="True"
+                    IsVisible="{Binding IsTreeLoading}" />
+
+                <ScrollViewer Grid.Row="1" IsVisible="{Binding !IsTreeLoading}">
+                    <ItemsControl ItemsSource="{Binding Sections}">
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate x:DataType="docs:DocumentationSectionNavItem">
+                                <StackPanel Margin="0,0,0,4">
+                                    <TextBlock
+                                        Margin="16,10,16,4"
+                                        FontSize="12"
+                                        FontWeight="SemiBold"
+                                        Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+                                        IsVisible="{Binding HasHeader}"
+                                        Text="{Binding Title}" />
+                                    <ItemsControl ItemsSource="{Binding Pages}">
+                                        <ItemsControl.ItemTemplate>
+                                            <DataTemplate x:DataType="docs:DocumentationPageNavItem">
+                                                <RadioButton
+                                                    Margin="8,0"
+                                                    Padding="8,6"
+                                                    HorizontalAlignment="Stretch"
+                                                    HorizontalContentAlignment="Left"
+                                                    Command="{Binding ((vm:DocumentationViewModel)DataContext).SelectPageCommand, RelativeSource={RelativeSource AncestorType=controls:UserControlBase}}"
+                                                    CommandParameter="{Binding}"
+                                                    Content="{Binding Title}"
+                                                    GroupName="DocsPages"
+                                                    IsChecked="{Binding IsSelected, Mode=OneWay}" />
+                                            </DataTemplate>
+                                        </ItemsControl.ItemTemplate>
+                                    </ItemsControl>
+                                </StackPanel>
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+                </ScrollViewer>
+            </Grid>
+        </Border>
+
+        <!--  Right pane: content  -->
+        <Grid Grid.Column="1">
+
+            <!--  Docs-not-available state  -->
+            <StackPanel
+                HorizontalAlignment="Center"
+                VerticalAlignment="Center"
+                IsVisible="{Binding IsDocsUnavailable}"
+                Spacing="8">
+                <fluentAvalonia:SymbolIcon
+                    HorizontalAlignment="Center"
+                    FontSize="48"
+                    Symbol="Document" />
+                <TextBlock
+                    HorizontalAlignment="Center"
+                    FontSize="18"
+                    FontWeight="SemiBold"
+                    Text="Documentation is not available yet" />
+                <TextBlock
+                    MaxWidth="420"
+                    HorizontalAlignment="Center"
+                    Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+                    Text="The documentation is coming soon. Please check back in a future release."
+                    TextAlignment="Center"
+                    TextWrapping="Wrap" />
+                <Button
+                    HorizontalAlignment="Center"
+                    Command="{Binding RetryCommand}"
+                    Content="Retry" />
+            </StackPanel>
+
+            <!--  Normal content area  -->
+            <Grid IsVisible="{Binding IsContentVisible}">
+
+                <!--  Error state  -->
+                <StackPanel
+                    HorizontalAlignment="Center"
+                    VerticalAlignment="Center"
+                    IsVisible="{Binding HasError}"
+                    Spacing="8">
+                    <fluentAvalonia:SymbolIcon
+                        HorizontalAlignment="Center"
+                        FontSize="48"
+                        Symbol="CloudOff" />
+                    <TextBlock
+                        MaxWidth="420"
+                        HorizontalAlignment="Center"
+                        Text="{Binding ErrorMessage}"
+                        TextAlignment="Center"
+                        TextWrapping="Wrap" />
+                    <Button
+                        HorizontalAlignment="Center"
+                        Command="{Binding RetryCommand}"
+                        Content="Retry" />
+                </StackPanel>
+
+                <!--  Page loading indicator  -->
+                <controls:ProgressRing
+                    Width="48"
+                    Height="48"
+                    HorizontalAlignment="Center"
+                    VerticalAlignment="Center"
+                    BorderThickness="4"
+                    IsIndeterminate="True"
+                    IsVisible="{Binding IsPageLoading}" />
+
+                <!--  Rendered markdown (MarkdownScrollViewer scrolls internally)  -->
+                <controls:DocumentationMarkdownViewer
+                    Margin="24,16"
+                    ImageBaseUrl="{Binding CurrentImageBaseUrl}"
+                    IsVisible="{Binding !HasError}"
+                    LinkCommand="{Binding LinkClickedCommand}"
+                    Markdown="{Binding CurrentMarkdown, Mode=OneWay}" />
+            </Grid>
+        </Grid>
+    </Grid>
+</controls:UserControlBase>
diff --git a/StabilityMatrix.Avalonia/Views/DocumentationPage.axaml.cs b/StabilityMatrix.Avalonia/Views/DocumentationPage.axaml.cs
new file mode 100644
index 000000000..ad15dd153
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Views/DocumentationPage.axaml.cs
@@ -0,0 +1,13 @@
+using Injectio.Attributes;
+using StabilityMatrix.Avalonia.Controls;
+
+namespace StabilityMatrix.Avalonia.Views;
+
+[RegisterSingleton<DocumentationPage>]
+public partial class DocumentationPage : UserControlBase
+{
+    public DocumentationPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/StabilityMatrix.Core/Api/IGitHubContentApi.cs b/StabilityMatrix.Core/Api/IGitHubContentApi.cs
new file mode 100644
index 000000000..21ec74869
--- /dev/null
+++ b/StabilityMatrix.Core/Api/IGitHubContentApi.cs
@@ -0,0 +1,25 @@
+using Refit;
+using StabilityMatrix.Core.Models.Api;
+
+namespace StabilityMatrix.Core.Api;
+
+/// <summary>
+/// Minimal GitHub REST API surface used by the in-app documentation viewer to
+/// discover the file listing under the docs folder.
+/// Base address: <c>https://api.github.com</c>.
+/// </summary>
+[Headers("User-Agent: StabilityMatrix", "Accept: application/vnd.github+json")]
+public interface IGitHubContentApi
+{
+    /// <summary>
+    /// Gets a git tree recursively. Pass <c>recursive=1</c> to include all nested entries.
+    /// </summary>
+    [Get("/repos/{owner}/{repo}/git/trees/{treeSha}")]
+    Task<GitHubTreeResponse> GetTree(
+        string owner,
+        string repo,
+        string treeSha,
+        [Query] [AliasAs("recursive")] int recursive = 1,
+        CancellationToken cancellationToken = default
+    );
+}
diff --git a/StabilityMatrix.Core/Models/Api/GitHubTreeResponse.cs b/StabilityMatrix.Core/Models/Api/GitHubTreeResponse.cs
new file mode 100644
index 000000000..33888ce00
--- /dev/null
+++ b/StabilityMatrix.Core/Models/Api/GitHubTreeResponse.cs
@@ -0,0 +1,41 @@
+using System.Text.Json.Serialization;
+
+namespace StabilityMatrix.Core.Models.Api;
+
+/// <summary>
+/// Response from the GitHub <c>git/trees</c> API (recursive listing).
+/// </summary>
+public record GitHubTreeResponse
+{
+    [JsonPropertyName("sha")]
+    public string? Sha { get; init; }
+
+    [JsonPropertyName("tree")]
+    public IReadOnlyList<GitHubTreeItem> Tree { get; init; } = [];
+
+    /// <summary>
+    /// Whether the returned tree was truncated by the API (too many entries).
+    /// </summary>
+    [JsonPropertyName("truncated")]
+    public bool Truncated { get; init; }
+}
+
+/// <summary>
+/// A single entry in a GitHub git tree.
+/// </summary>
+public record GitHubTreeItem
+{
+    /// <summary>Path relative to the tree root (e.g. <c>getting-started/overview.md</c>).</summary>
+    [JsonPropertyName("path")]
+    public string Path { get; init; } = string.Empty;
+
+    /// <summary>Either <c>blob</c> (file) or <c>tree</c> (directory).</summary>
+    [JsonPropertyName("type")]
+    public string Type { get; init; } = string.Empty;
+
+    [JsonPropertyName("sha")]
+    public string? Sha { get; init; }
+
+    [JsonIgnore]
+    public bool IsBlob => Type == "blob";
+}
diff --git a/StabilityMatrix.Core/Models/Documentation/DocumentationConstants.cs b/StabilityMatrix.Core/Models/Documentation/DocumentationConstants.cs
new file mode 100644
index 000000000..9265f78e8
--- /dev/null
+++ b/StabilityMatrix.Core/Models/Documentation/DocumentationConstants.cs
@@ -0,0 +1,32 @@
+namespace StabilityMatrix.Core.Models.Documentation;
+
+/// <summary>
+/// Central location for the documentation source repository coordinates.
+/// The in-app documentation viewer fetches its content from this repo's <c>docs/</c> folder.
+/// </summary>
+public static class DocumentationConstants
+{
+    /// <summary>GitHub repository owner.</summary>
+    public const string Owner = "LykosAI";
+
+    /// <summary>GitHub repository name.</summary>
+    public const string Repo = "StabilityMatrix";
+
+    /// <summary>Branch that the docs are read from.</summary>
+    public const string Branch = "main";
+
+    /// <summary>Root folder within the repository that contains the documentation.</summary>
+    public const string DocsRoot = "docs";
+
+    /// <summary>
+    /// Base URL for raw file content, e.g.
+    /// <c>https://raw.githubusercontent.com/{Owner}/{Repo}/{Branch}/</c>.
+    /// </summary>
+    public static string RawBaseUrl => $"https://raw.githubusercontent.com/{Owner}/{Repo}/{Branch}/";
+
+    /// <summary>
+    /// Builds the raw content URL for a path relative to the repository root
+    /// (e.g. <c>docs/getting-started/overview.md</c>).
+    /// </summary>
+    public static string GetRawUrl(string repoRelativePath) => RawBaseUrl + repoRelativePath.TrimStart('/');
+}
diff --git a/StabilityMatrix.Core/Models/Documentation/DocumentationPage.cs b/StabilityMatrix.Core/Models/Documentation/DocumentationPage.cs
new file mode 100644
index 000000000..4651c768f
--- /dev/null
+++ b/StabilityMatrix.Core/Models/Documentation/DocumentationPage.cs
@@ -0,0 +1,15 @@
+namespace StabilityMatrix.Core.Models.Documentation;
+
+/// <summary>
+/// A single documentation page discovered in the docs tree.
+/// </summary>
+public record DocumentationPage
+{
+    /// <summary>
+    /// Path relative to the docs root, e.g. <c>getting-started/overview.md</c> or <c>README.md</c>.
+    /// </summary>
+    public required string Path { get; init; }
+
+    /// <summary>Humanized display title, e.g. "Overview".</summary>
+    public required string Title { get; init; }
+}
diff --git a/StabilityMatrix.Core/Models/Documentation/DocumentationPathResolver.cs b/StabilityMatrix.Core/Models/Documentation/DocumentationPathResolver.cs
new file mode 100644
index 000000000..0515e6f62
--- /dev/null
+++ b/StabilityMatrix.Core/Models/Documentation/DocumentationPathResolver.cs
@@ -0,0 +1,236 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace StabilityMatrix.Core.Models.Documentation;
+
+/// <summary>
+/// Pure helpers for the documentation viewer: humanizing file/folder names and
+/// resolving links and image paths encountered inside rendered markdown.
+/// Kept free of Avalonia/IO dependencies so it can be unit tested in isolation.
+/// </summary>
+public static class DocumentationPathResolver
+{
+    /// <summary>
+    /// The classification of a link clicked within a rendered markdown page.
+    /// </summary>
+    public enum LinkKind
+    {
+        /// <summary>Relative link to another markdown page inside the docs (navigate in-app).</summary>
+        InternalPage,
+
+        /// <summary>Absolute http(s) link (open in the system browser).</summary>
+        External,
+
+        /// <summary>In-page anchor (e.g. <c>#section</c>) or otherwise unhandled — ignore.</summary>
+        Anchor,
+    }
+
+    /// <summary>
+    /// Result of classifying/resolving a clicked link.
+    /// </summary>
+    public readonly record struct ResolvedLink(LinkKind Kind, string Target);
+
+    /// <summary>
+    /// Converts a docs file or folder name into a human friendly title.
+    /// Strips a trailing <c>.md</c>, replaces kebab/snake separators with spaces, and title-cases.
+    /// <c>README</c> maps to "Home".
+    /// </summary>
+    public static string Humanize(string name)
+    {
+        if (string.IsNullOrWhiteSpace(name))
+            return string.Empty;
+
+        // Drop a trailing .md extension if present
+        if (name.EndsWith(".md", StringComparison.OrdinalIgnoreCase))
+            name = name[..^3];
+
+        if (name.Equals("README", StringComparison.OrdinalIgnoreCase))
+            return "Home";
+
+        var words = name.Replace('-', ' ')
+            .Replace('_', ' ')
+            .Split(' ', StringSplitOptions.RemoveEmptyEntries);
+
+        var builder = new StringBuilder();
+        for (var i = 0; i < words.Length; i++)
+        {
+            if (i > 0)
+                builder.Append(' ');
+            builder.Append(TitleCaseWord(words[i]));
+        }
+
+        return builder.ToString();
+    }
+
+    private static string TitleCaseWord(string word)
+    {
+        // Preserve all-caps acronyms (e.g. "GPU", "AMD", "CUDA")
+        if (word.Length > 1 && word.All(char.IsUpper))
+            return word;
+
+        return char.ToUpper(word[0], CultureInfo.InvariantCulture) + word[1..].ToLowerInvariant();
+    }
+
+    /// <summary>
+    /// Classifies a clicked link relative to the currently displayed page.
+    /// </summary>
+    /// <param name="currentPagePath">
+    /// Path of the current page relative to the docs root (e.g. <c>advanced/environment-variables.md</c>).
+    /// </param>
+    /// <param name="href">The raw href from the markdown link.</param>
+    /// <returns>
+    /// For <see cref="LinkKind.InternalPage"/>, <c>Target</c> is the resolved docs-root-relative path.
+    /// For <see cref="LinkKind.External"/>, <c>Target</c> is the absolute URL.
+    /// For <see cref="LinkKind.Anchor"/>, <c>Target</c> is the original href.
+    /// </returns>
+    public static ResolvedLink ResolveLink(string currentPagePath, string href)
+    {
+        if (string.IsNullOrWhiteSpace(href))
+            return new ResolvedLink(LinkKind.Anchor, href ?? string.Empty);
+
+        href = href.Trim();
+
+        // In-page anchor
+        if (href.StartsWith('#'))
+            return new ResolvedLink(LinkKind.Anchor, href);
+
+        // Absolute http(s) (also covers mailto: etc. -> treat as external / open-in-browser)
+        if (
+            Uri.TryCreate(href, UriKind.Absolute, out var abs)
+            && (
+                abs.Scheme == Uri.UriSchemeHttp
+                || abs.Scheme == Uri.UriSchemeHttps
+                || abs.Scheme == Uri.UriSchemeMailto
+            )
+        )
+        {
+            return new ResolvedLink(LinkKind.External, href);
+        }
+
+        // Strip any anchor fragment from a relative path before resolving
+        var fragmentIndex = href.IndexOf('#');
+        if (fragmentIndex >= 0)
+            href = href[..fragmentIndex];
+
+        if (string.IsNullOrEmpty(href))
+            return new ResolvedLink(LinkKind.Anchor, "#");
+
+        // Relative markdown page -> resolve against the current page's folder
+        if (href.EndsWith(".md", StringComparison.OrdinalIgnoreCase))
+        {
+            var resolved = ResolveRelativePath(currentPagePath, href);
+            return new ResolvedLink(LinkKind.InternalPage, resolved);
+        }
+
+        // Anything else relative (rare) -> treat as external best-effort against raw base
+        return new ResolvedLink(
+            LinkKind.External,
+            DocumentationConstants.GetRawUrl(CombineDocsPath(ResolveRelativePath(currentPagePath, href)))
+        );
+    }
+
+    // Matches markdown image syntax ![alt](src "optional title")
+    private static readonly Regex ImageRegex = new(
+        @"!\[(?<alt>[^\]]*)\]\((?<src>[^)\s]+)(?<rest>[^)]*)\)",
+        RegexOptions.Compiled
+    );
+
+    /// <summary>
+    /// Rewrites relative image sources in a markdown document into absolute raw URLs so they
+    /// render inside the viewer. Absolute URLs are left untouched.
+    /// </summary>
+    /// <param name="currentPagePath">Docs-root-relative path of the current page.</param>
+    /// <param name="markdown">The raw markdown content.</param>
+    public static string RewriteImageUrls(string currentPagePath, string markdown)
+    {
+        if (string.IsNullOrEmpty(markdown))
+            return markdown;
+
+        return ImageRegex.Replace(
+            markdown,
+            match =>
+            {
+                var alt = match.Groups["alt"].Value;
+                var src = match.Groups["src"].Value;
+                var rest = match.Groups["rest"].Value;
+                var resolved = ResolveImageUrl(currentPagePath, src);
+                return $"![{alt}]({resolved}{rest})";
+            }
+        );
+    }
+
+    /// <summary>
+    /// Resolves a relative image path in the current page into an absolute raw URL so it renders.
+    /// </summary>
+    /// <param name="currentPagePath">Docs-root-relative path of the current page.</param>
+    /// <param name="src">The raw image src from the markdown.</param>
+    public static string ResolveImageUrl(string currentPagePath, string src)
+    {
+        if (string.IsNullOrWhiteSpace(src))
+            return src;
+
+        src = src.Trim();
+
+        // Already absolute -> leave as-is
+        if (Uri.TryCreate(src, UriKind.Absolute, out _))
+            return src;
+
+        var resolvedDocsRelative = ResolveRelativePath(currentPagePath, src);
+        return DocumentationConstants.GetRawUrl(CombineDocsPath(resolvedDocsRelative));
+    }
+
+    /// <summary>
+    /// Resolves a relative path (e.g. <c>../images/foo.png</c>) against the folder of the
+    /// current page and returns a normalized docs-root-relative path (using forward slashes,
+    /// with any leading <c>./</c> and traversal <c>..</c> segments collapsed).
+    /// </summary>
+    public static string ResolveRelativePath(string currentPagePath, string relative)
+    {
+        relative = relative.Replace('\\', '/');
+
+        // Absolute-from-docs-root (leading slash) -> relative to docs root
+        if (relative.StartsWith('/'))
+            return NormalizeSegments(relative.TrimStart('/').Split('/'));
+
+        var currentDir = GetDirectory(currentPagePath);
+        var combined = string.IsNullOrEmpty(currentDir) ? relative : currentDir + "/" + relative;
+        return NormalizeSegments(combined.Split('/'));
+    }
+
+    private static string NormalizeSegments(string[] segments)
+    {
+        var stack = new System.Collections.Generic.List<string>();
+        foreach (var segment in segments)
+        {
+            if (segment is "" or ".")
+                continue;
+
+            if (segment == "..")
+            {
+                if (stack.Count > 0)
+                    stack.RemoveAt(stack.Count - 1);
+                continue;
+            }
+
+            stack.Add(segment);
+        }
+
+        return string.Join('/', stack);
+    }
+
+    private static string GetDirectory(string path)
+    {
+        path = path.Replace('\\', '/');
+        var index = path.LastIndexOf('/');
+        return index < 0 ? string.Empty : path[..index];
+    }
+
+    /// <summary>
+    /// Prefixes a docs-root-relative path with the repository docs root folder.
+    /// </summary>
+    private static string CombineDocsPath(string docsRelativePath) =>
+        $"{DocumentationConstants.DocsRoot}/{docsRelativePath.TrimStart('/')}";
+}
diff --git a/StabilityMatrix.Core/Models/Documentation/DocumentationSection.cs b/StabilityMatrix.Core/Models/Documentation/DocumentationSection.cs
new file mode 100644
index 000000000..7a0fba8aa
--- /dev/null
+++ b/StabilityMatrix.Core/Models/Documentation/DocumentationSection.cs
@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+
+namespace StabilityMatrix.Core.Models.Documentation;
+
+/// <summary>
+/// A group of documentation pages that share a section folder (e.g. "Getting Started").
+/// </summary>
+public record DocumentationSection
+{
+    /// <summary>Humanized section title, e.g. "Getting Started".</summary>
+    public required string Title { get; init; }
+
+    /// <summary>
+    /// The raw section folder name relative to the docs root, e.g. <c>getting-started</c>.
+    /// Empty string for the root-level section.
+    /// </summary>
+    public required string FolderName { get; init; }
+
+    /// <summary>Pages within this section, in listing order.</summary>
+    public IReadOnlyList<DocumentationPage> Pages { get; init; } = [];
+}
diff --git a/StabilityMatrix.Core/Services/DocumentationNotAvailableException.cs b/StabilityMatrix.Core/Services/DocumentationNotAvailableException.cs
new file mode 100644
index 000000000..1fe761d02
--- /dev/null
+++ b/StabilityMatrix.Core/Services/DocumentationNotAvailableException.cs
@@ -0,0 +1,15 @@
+using System;
+
+namespace StabilityMatrix.Core.Services;
+
+/// <summary>
+/// Thrown when the documentation folder is not present in the source repository yet.
+/// </summary>
+public class DocumentationNotAvailableException : Exception
+{
+    public DocumentationNotAvailableException(string message)
+        : base(message) { }
+
+    public DocumentationNotAvailableException(string message, Exception innerException)
+        : base(message, innerException) { }
+}
diff --git a/StabilityMatrix.Core/Services/DocumentationService.cs b/StabilityMatrix.Core/Services/DocumentationService.cs
new file mode 100644
index 000000000..50ad14204
--- /dev/null
+++ b/StabilityMatrix.Core/Services/DocumentationService.cs
@@ -0,0 +1,283 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Injectio.Attributes;
+using Microsoft.Extensions.Logging;
+using Refit;
+using StabilityMatrix.Core.Api;
+using StabilityMatrix.Core.Models.Api;
+using StabilityMatrix.Core.Models.Documentation;
+using StabilityMatrix.Core.Models.FileInterfaces;
+
+namespace StabilityMatrix.Core.Services;
+
+[RegisterSingleton<IDocumentationService, DocumentationService>]
+public class DocumentationService(
+    ILogger<DocumentationService> logger,
+    IGitHubContentApi gitHubContentApi,
+    IHttpClientFactory httpClientFactory
+) : IDocumentationService
+{
+    private static readonly TimeSpan CacheTtl = TimeSpan.FromDays(1);
+
+    private const string TreeCacheFileName = "docs-tree.md";
+
+    private static DirectoryPath CacheDir =>
+        new(Path.Combine(Path.GetTempPath(), "StabilityMatrix", "Cache", "Docs"));
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<DocumentationSection>> GetSectionsAsync(
+        bool forceRefresh = false,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var cacheFile = CacheDir.JoinFile(TreeCacheFileName);
+
+        // Fetch fresh listing, falling back to any cached copy on failure.
+        List<string>? paths = null;
+
+        if (!forceRefresh && IsFresh(cacheFile))
+        {
+            paths = await ReadCachedPathsAsync(cacheFile, cancellationToken).ConfigureAwait(false);
+        }
+
+        if (paths is null)
+        {
+            try
+            {
+                paths = await FetchDocsPathsAsync(cancellationToken).ConfigureAwait(false);
+                await WriteCachedPathsAsync(cacheFile, paths, cancellationToken).ConfigureAwait(false);
+            }
+            catch (DocumentationNotAvailableException)
+            {
+                throw;
+            }
+            catch (Exception e) when (e is not OperationCanceledException)
+            {
+                logger.LogWarning(e, "Failed to fetch docs tree, attempting to use cached copy");
+                paths = await ReadCachedPathsAsync(cacheFile, cancellationToken).ConfigureAwait(false);
+                if (paths is null)
+                    throw;
+            }
+        }
+
+        return BuildSections(paths);
+    }
+
+    /// <inheritdoc />
+    public async Task<string> GetPageMarkdownAsync(
+        string docsRelativePath,
+        bool forceRefresh = false,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var cacheFile = CacheDir.JoinFile(GetCacheFileName(docsRelativePath));
+
+        if (!forceRefresh && IsFresh(cacheFile))
+        {
+            try
+            {
+                return await cacheFile.ReadAllTextAsync(cancellationToken).ConfigureAwait(false);
+            }
+            catch (Exception e) when (e is not OperationCanceledException)
+            {
+                logger.LogWarning(e, "Failed to read cached markdown for {Path}", docsRelativePath);
+            }
+        }
+
+        var url = DocumentationConstants.GetRawUrl($"{DocumentationConstants.DocsRoot}/{docsRelativePath}");
+
+        try
+        {
+            using var client = httpClientFactory.CreateClient();
+            client.Timeout = TimeSpan.FromSeconds(30);
+            var markdown = await client.GetStringAsync(url, cancellationToken).ConfigureAwait(false);
+
+            CacheDir.Create();
+            await cacheFile.WriteAllTextAsync(markdown, cancellationToken).ConfigureAwait(false);
+            return markdown;
+        }
+        catch (Exception e) when (e is not OperationCanceledException)
+        {
+            logger.LogWarning(
+                e,
+                "Failed to fetch markdown for {Path}, attempting cached copy",
+                docsRelativePath
+            );
+
+            if (cacheFile.Exists)
+                return await cacheFile.ReadAllTextAsync(cancellationToken).ConfigureAwait(false);
+
+            throw;
+        }
+    }
+
+    private async Task<List<string>> FetchDocsPathsAsync(CancellationToken cancellationToken)
+    {
+        GitHubTreeResponse tree;
+        try
+        {
+            tree = await gitHubContentApi
+                .GetTree(
+                    DocumentationConstants.Owner,
+                    DocumentationConstants.Repo,
+                    DocumentationConstants.Branch,
+                    cancellationToken: cancellationToken
+                )
+                .ConfigureAwait(false);
+        }
+        catch (ApiException e) when (e.StatusCode == HttpStatusCode.NotFound)
+        {
+            throw new DocumentationNotAvailableException("Documentation repository or branch not found.", e);
+        }
+
+        var prefix = DocumentationConstants.DocsRoot + "/";
+
+        var paths = tree
+            .Tree.Where(item => item.IsBlob && item.Path.StartsWith(prefix, StringComparison.Ordinal))
+            .Select(item => item.Path[prefix.Length..])
+            .Where(IsDocPage)
+            .ToList();
+
+        if (paths.Count == 0)
+            throw new DocumentationNotAvailableException(
+                "Documentation folder is empty or not available yet."
+            );
+
+        return paths;
+    }
+
+    /// <summary>
+    /// Whether a docs-relative path should be shown as a navigable page.
+    /// Excludes images, .gitkeep placeholders, and non-markdown files.
+    /// </summary>
+    private static bool IsDocPage(string docsRelativePath)
+    {
+        if (docsRelativePath.StartsWith("images/", StringComparison.OrdinalIgnoreCase))
+            return false;
+
+        var fileName = docsRelativePath.Split('/').Last();
+        if (fileName.Equals(".gitkeep", StringComparison.OrdinalIgnoreCase))
+            return false;
+
+        return fileName.EndsWith(".md", StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>
+    /// Groups discovered docs paths into ordered sections, with the root README first.
+    /// </summary>
+    internal static IReadOnlyList<DocumentationSection> BuildSections(IReadOnlyList<string> docsRelativePaths)
+    {
+        var rootPages = new List<DocumentationPage>();
+        var sections = new Dictionary<string, List<DocumentationPage>>(StringComparer.OrdinalIgnoreCase);
+        var sectionOrder = new List<string>();
+
+        foreach (var path in docsRelativePaths)
+        {
+            var separatorIndex = path.IndexOf('/');
+            if (separatorIndex < 0)
+            {
+                // Root-level page
+                rootPages.Add(
+                    new DocumentationPage { Path = path, Title = DocumentationPathResolver.Humanize(path) }
+                );
+                continue;
+            }
+
+            var folder = path[..separatorIndex];
+            var fileName = path.Split('/').Last();
+
+            if (!sections.TryGetValue(folder, out var list))
+            {
+                list = [];
+                sections[folder] = list;
+                sectionOrder.Add(folder);
+            }
+
+            list.Add(
+                new DocumentationPage { Path = path, Title = DocumentationPathResolver.Humanize(fileName) }
+            );
+        }
+
+        var result = new List<DocumentationSection>();
+
+        // Root README first, then any other root-level pages, all under an unnamed root section.
+        if (rootPages.Count > 0)
+        {
+            var orderedRoot = rootPages
+                .OrderByDescending(p => p.Path.Equals("README.md", StringComparison.OrdinalIgnoreCase))
+                .ThenBy(p => p.Title, StringComparer.OrdinalIgnoreCase)
+                .ToList();
+
+            result.Add(
+                new DocumentationSection
+                {
+                    Title = string.Empty,
+                    FolderName = string.Empty,
+                    Pages = orderedRoot,
+                }
+            );
+        }
+
+        foreach (var folder in sectionOrder.OrderBy(f => f, StringComparer.OrdinalIgnoreCase))
+        {
+            var pages = sections[folder].OrderBy(p => p.Title, StringComparer.OrdinalIgnoreCase).ToList();
+
+            result.Add(
+                new DocumentationSection
+                {
+                    Title = DocumentationPathResolver.Humanize(folder),
+                    FolderName = folder,
+                    Pages = pages,
+                }
+            );
+        }
+
+        return result;
+    }
+
+    private static bool IsFresh(FilePath cacheFile) =>
+        cacheFile.Exists && DateTime.UtcNow - File.GetLastWriteTimeUtc(cacheFile) < CacheTtl;
+
+    private static async Task<List<string>?> ReadCachedPathsAsync(FilePath cacheFile, CancellationToken ct)
+    {
+        if (!cacheFile.Exists)
+            return null;
+
+        var text = await cacheFile.ReadAllTextAsync(ct).ConfigureAwait(false);
+        return text.Split('\n', StringSplitOptions.RemoveEmptyEntries)
+            .Select(line => line.Trim())
+            .Where(line => line.Length > 0)
+            .ToList();
+    }
+
+    private static async Task WriteCachedPathsAsync(
+        FilePath cacheFile,
+        List<string> paths,
+        CancellationToken ct
+    )
+    {
+        CacheDir.Create();
+        await cacheFile.WriteAllTextAsync(string.Join('\n', paths), ct).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Maps a docs-relative path to a safe flat cache file name.
+    /// </summary>
+    private static string GetCacheFileName(string docsRelativePath)
+    {
+        var builder = new StringBuilder(docsRelativePath.Length);
+        foreach (var c in docsRelativePath)
+        {
+            builder.Append(c is '/' or '\\' ? '_' : c);
+        }
+
+        return "page_" + builder;
+    }
+}
diff --git a/StabilityMatrix.Core/Services/IDocumentationService.cs b/StabilityMatrix.Core/Services/IDocumentationService.cs
new file mode 100644
index 000000000..b1574c495
--- /dev/null
+++ b/StabilityMatrix.Core/Services/IDocumentationService.cs
@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using StabilityMatrix.Core.Models.Documentation;
+
+namespace StabilityMatrix.Core.Services;
+
+/// <summary>
+/// Fetches and caches the in-app documentation content from the docs repository.
+/// </summary>
+public interface IDocumentationService
+{
+    /// <summary>
+    /// Gets the documentation navigation tree, grouped into sections.
+    /// The root <c>README.md</c> (if present) is returned as the first entry of the
+    /// root section so callers can treat it as the landing page.
+    /// </summary>
+    /// <exception cref="DocumentationNotAvailableException">
+    /// Thrown when the docs folder does not exist in the source repository.
+    /// </exception>
+    Task<IReadOnlyList<DocumentationSection>> GetSectionsAsync(
+        bool forceRefresh = false,
+        CancellationToken cancellationToken = default
+    );
+
+    /// <summary>
+    /// Gets the raw markdown for a page path relative to the docs root
+    /// (e.g. <c>getting-started/overview.md</c>).
+    /// </summary>
+    Task<string> GetPageMarkdownAsync(
+        string docsRelativePath,
+        bool forceRefresh = false,
+        CancellationToken cancellationToken = default
+    );
+}
diff --git a/StabilityMatrix.Tests/Core/DocumentationPathResolverTests.cs b/StabilityMatrix.Tests/Core/DocumentationPathResolverTests.cs
new file mode 100644
index 000000000..c4db15acc
--- /dev/null
+++ b/StabilityMatrix.Tests/Core/DocumentationPathResolverTests.cs
@@ -0,0 +1,153 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using StabilityMatrix.Core.Models.Documentation;
+
+namespace StabilityMatrix.Tests.Core;
+
+[TestClass]
+public class DocumentationPathResolverTests
+{
+    [DataTestMethod]
+    [DataRow("overview.md", "Overview")]
+    [DataRow("environment-variables.md", "Environment Variables")]
+    [DataRow("first-launch", "First Launch")]
+    [DataRow("getting-started", "Getting Started")]
+    [DataRow("data_directory", "Data Directory")]
+    [DataRow("README.md", "Home")]
+    [DataRow("README", "Home")]
+    public void Humanize_ProducesTitleCase(string input, string expected)
+    {
+        Assert.AreEqual(expected, DocumentationPathResolver.Humanize(input));
+    }
+
+    [TestMethod]
+    public void Humanize_PreservesAcronyms()
+    {
+        Assert.AreEqual("GPU Backends", DocumentationPathResolver.Humanize("GPU-backends"));
+    }
+
+    [TestMethod]
+    public void ResolveLink_SiblingMarkdown_ResolvesRelativeToCurrentFolder()
+    {
+        var result = DocumentationPathResolver.ResolveLink(
+            "advanced/environment-variables.md",
+            "overview.md"
+        );
+
+        Assert.AreEqual(DocumentationPathResolver.LinkKind.InternalPage, result.Kind);
+        Assert.AreEqual("advanced/overview.md", result.Target);
+    }
+
+    [TestMethod]
+    public void ResolveLink_ParentMarkdown_ResolvesTraversal()
+    {
+        var result = DocumentationPathResolver.ResolveLink(
+            "advanced/environment-variables.md",
+            "../README.md"
+        );
+
+        Assert.AreEqual(DocumentationPathResolver.LinkKind.InternalPage, result.Kind);
+        Assert.AreEqual("README.md", result.Target);
+    }
+
+    [TestMethod]
+    public void ResolveLink_MarkdownFromRoot_ResolvesIntoSubfolder()
+    {
+        var result = DocumentationPathResolver.ResolveLink("README.md", "getting-started/overview.md");
+
+        Assert.AreEqual(DocumentationPathResolver.LinkKind.InternalPage, result.Kind);
+        Assert.AreEqual("getting-started/overview.md", result.Target);
+    }
+
+    [TestMethod]
+    public void ResolveLink_MarkdownWithFragment_StripsFragment()
+    {
+        var result = DocumentationPathResolver.ResolveLink(
+            "advanced/environment-variables.md",
+            "overview.md#setting-variables"
+        );
+
+        Assert.AreEqual(DocumentationPathResolver.LinkKind.InternalPage, result.Kind);
+        Assert.AreEqual("advanced/overview.md", result.Target);
+    }
+
+    [TestMethod]
+    public void ResolveLink_External_IsClassifiedExternal()
+    {
+        var result = DocumentationPathResolver.ResolveLink(
+            "advanced/environment-variables.md",
+            "https://docs.pytorch.org/docs/stable/torch_environment_variables.html"
+        );
+
+        Assert.AreEqual(DocumentationPathResolver.LinkKind.External, result.Kind);
+        Assert.AreEqual(
+            "https://docs.pytorch.org/docs/stable/torch_environment_variables.html",
+            result.Target
+        );
+    }
+
+    [TestMethod]
+    public void ResolveLink_Anchor_IsClassifiedAnchor()
+    {
+        var result = DocumentationPathResolver.ResolveLink(
+            "advanced/environment-variables.md",
+            "#common-variables"
+        );
+
+        Assert.AreEqual(DocumentationPathResolver.LinkKind.Anchor, result.Kind);
+    }
+
+    [TestMethod]
+    public void ResolveImageUrl_RelativeParentPath_ResolvesToRawUrl()
+    {
+        var result = DocumentationPathResolver.ResolveImageUrl(
+            "advanced/environment-variables.md",
+            "../images/advanced/envar-window.png"
+        );
+
+        Assert.AreEqual(
+            "https://raw.githubusercontent.com/LykosAI/StabilityMatrix/main/docs/images/advanced/envar-window.png",
+            result
+        );
+    }
+
+    [TestMethod]
+    public void ResolveImageUrl_AbsoluteUrl_IsUnchanged()
+    {
+        const string absolute = "https://example.com/foo.png";
+        var result = DocumentationPathResolver.ResolveImageUrl("advanced/overview.md", absolute);
+
+        Assert.AreEqual(absolute, result);
+    }
+
+    [TestMethod]
+    public void RewriteImageUrls_RewritesOnlyRelativeImages()
+    {
+        const string markdown =
+            "Text\n\n![editor](../images/advanced/envar-window.png)\n\n![remote](https://example.com/x.png)\n";
+
+        var result = DocumentationPathResolver.RewriteImageUrls(
+            "advanced/environment-variables.md",
+            markdown
+        );
+
+        StringAssert.Contains(
+            result,
+            "![editor](https://raw.githubusercontent.com/LykosAI/StabilityMatrix/main/docs/images/advanced/envar-window.png)"
+        );
+        // Absolute image left untouched
+        StringAssert.Contains(result, "![remote](https://example.com/x.png)");
+    }
+
+    [TestMethod]
+    public void RewriteImageUrls_PreservesImageTitle()
+    {
+        const string markdown = "![alt](img/pic.png \"A title\")";
+
+        var result = DocumentationPathResolver.RewriteImageUrls("getting-started/overview.md", markdown);
+
+        StringAssert.Contains(
+            result,
+            "https://raw.githubusercontent.com/LykosAI/StabilityMatrix/main/docs/getting-started/img/pic.png \"A title\""
+        );
+    }
+}