app: add code for macOS and Windows apps under 'app' (#12933)

* app: add code for macOS and Windows apps under 'app'

* app: add readme

* app: windows and linux only for now

* ci: fix ui CI validation

---------
Co-authored-by: jmorganca <jmorganca@gmail.com>

.github/workflows/release.yaml

@@ -15,44 +15,56 @@ jobs:
     environment: release
     outputs:
       GOFLAGS: ${{ steps.goflags.outputs.GOFLAGS }}
+      VERSION: ${{ steps.goflags.outputs.VERSION }}
     steps:
       - uses: actions/checkout@v4
       - name: Set environment
         id: goflags
         run: |
           echo GOFLAGS="'-ldflags=-w -s \"-X=github.com/ollama/ollama/version.Version=${GITHUB_REF_NAME#v}\" \"-X=github.com/ollama/ollama/server.mode=release\"'" >>$GITHUB_OUTPUT
+          echo VERSION="${GITHUB_REF_NAME#v}" >>$GITHUB_OUTPUT
 
   darwin-build:
-    runs-on: macos-13-xlarge
+    runs-on: macos-14-xlarge
     environment: release
     needs: setup-environment
-    strategy:
-      matrix:
-        os: [darwin]
-        arch: [amd64, arm64]
     env:
       GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
+      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
+      APPLE_IDENTITY: ${{ secrets.APPLE_IDENTITY }}
+      APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+      APPLE_TEAM_ID: ${{ vars.APPLE_TEAM_ID }}
+      APPLE_ID: ${{ vars.APPLE_ID }}
+      MACOS_SIGNING_KEY: ${{ secrets.MACOS_SIGNING_KEY }}
+      MACOS_SIGNING_KEY_PASSWORD: ${{ secrets.MACOS_SIGNING_KEY_PASSWORD }}
+      CGO_CFLAGS: '-mmacosx-version-min=14.0 -O3'
+      CGO_CXXFLAGS: '-mmacosx-version-min=14.0 -O3'
+      CGO_LDFLAGS: '-mmacosx-version-min=14.0 -O3'
     steps:
       - uses: actions/checkout@v4
+      - run: |
+          echo $MACOS_SIGNING_KEY | base64 --decode > certificate.p12
+          security create-keychain -p password build.keychain
+          security default-keychain -s build.keychain
+          security unlock-keychain -p password build.keychain
+          security import certificate.p12 -k build.keychain -P $MACOS_SIGNING_KEY_PASSWORD -T /usr/bin/codesign
+          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k password build.keychain
+          security set-keychain-settings -lut 3600 build.keychain
       - uses: actions/setup-go@v5
         with:
           go-version-file: go.mod
       - run: |
-          go build -o dist/ .
-        env:
-          GOOS: ${{ matrix.os }}
-          GOARCH: ${{ matrix.arch }}
-          CGO_ENABLED: 1
-          CGO_CPPFLAGS: '-mmacosx-version-min=11.3'
-      - if: matrix.arch == 'amd64'
+          ./scripts/build_darwin.sh
+      - name: Log build results
         run: |
-          cmake --preset CPU -DCMAKE_OSX_DEPLOYMENT_TARGET=11.3 -DCMAKE_SYSTEM_PROCESSOR=x86_64 -DCMAKE_OSX_ARCHITECTURES=x86_64
-          cmake --build --parallel --preset CPU
-          cmake --install build --component CPU --strip --parallel 8
+          ls -l dist/
       - uses: actions/upload-artifact@v4
         with:
-          name: build-${{ matrix.os }}-${{ matrix.arch }}
-          path: dist/*
+          name: bundles-darwin
+          path: |
+            dist/*.tgz
+            dist/*.zip
+            dist/*.dmg
 
   windows-depends:
     strategy:
@@ -72,7 +84,6 @@ jobs:
               - '"cublas_dev"'
             cuda-version: '12.8'
             flags: ''
-            runner_dir: 'cuda_v12'
           - os: windows
             arch: amd64
             preset: 'CUDA 13'
@@ -87,14 +98,12 @@ jobs:
               - '"nvptxcompiler"'
             cuda-version: '13.0'
             flags: ''
-            runner_dir: 'cuda_v13'
           - os: windows
             arch: amd64
             preset: 'ROCm 6'
             install: https://download.amd.com/developer/eula/rocm-hub/AMD-Software-PRO-Edition-24.Q4-WinSvr2022-For-HIP.exe
             rocm-version: '6.2'
             flags: '-DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_FLAGS="-parallel-jobs=4 -Wno-ignored-attributes -Wno-deprecated-pragma" -DCMAKE_CXX_FLAGS="-parallel-jobs=4 -Wno-ignored-attributes -Wno-deprecated-pragma"'
-            runner_dir: 'rocm'
     runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
     environment: release
     env:
@@ -160,12 +169,15 @@ jobs:
         run: |
           Import-Module 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'
           Enter-VsDevShell -VsInstallPath 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' -SkipAutomaticLocation  -DevCmdArguments '-arch=x64 -no_logo'
-          cmake --preset "${{ matrix.preset }}" ${{ matrix.flags }} -DOLLAMA_RUNNER_DIR="${{ matrix.runner_dir }}"
-          cmake --build --parallel --preset "${{ matrix.preset }}"
-          cmake --install build --component "${{ startsWith(matrix.preset, 'CUDA ') && 'CUDA' || startsWith(matrix.preset, 'ROCm ') && 'HIP' || 'CPU' }}" --strip --parallel 8
+          cmake --preset "${{ matrix.preset }}" ${{ matrix.flags }} --install-prefix "$((pwd).Path)\dist\${{ matrix.os }}-${{ matrix.arch }}"
+          cmake --build --parallel ([Environment]::ProcessorCount) --preset "${{ matrix.preset }}"
+          cmake --install build --component "${{ startsWith(matrix.preset, 'CUDA ') && 'CUDA' || startsWith(matrix.preset, 'ROCm ') && 'HIP' || 'CPU' }}" --strip
           Remove-Item -Path dist\lib\ollama\rocm\rocblas\library\*gfx906* -ErrorAction SilentlyContinue
         env:
           CMAKE_GENERATOR: Ninja
+      - name: Log build results
+        run: |
+          gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
       - uses: actions/upload-artifact@v4
         with:
           name: depends-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.preset }}
@@ -188,6 +200,7 @@ jobs:
     needs: [setup-environment]
     env:
       GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
+      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
     steps:
       - name: Install ARM64 system dependencies
         if: matrix.arch == 'arm64'
@@ -198,6 +211,9 @@ jobs:
           iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
           echo "C:\ProgramData\chocolatey\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
 
+          Invoke-WebRequest -Uri https://aka.ms/vs/17/release/vc_redist.arm64.exe -OutFile "${{ runner.temp }}\vc_redist.arm64.exe"
+          Start-Process -FilePath "${{ runner.temp }}\vc_redist.arm64.exe" -ArgumentList @("/install", "/quiet", "/norestart") -NoNewWindow -Wait
+
           choco install -y --no-progress git gzip
           echo "C:\Program Files\Git\cmd" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
       - name: Install clang and gcc-compat
@@ -223,13 +239,72 @@ jobs:
             exit 1
           }
           $ErrorActionPreference='Stop'
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
       - run: |
-          go build -o dist/${{ matrix.os }}-${{ matrix.arch }}/ .
+          ./scripts/build_windows ollama app
+      - name: Log build results
+        run: |
+          gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
       - uses: actions/upload-artifact@v4
         with:
           name: build-${{ matrix.os }}-${{ matrix.arch }}
           path: |
-            dist\${{ matrix.os }}-${{ matrix.arch }}\*.exe
+            dist\*
+
+  windows-app:
+    runs-on: windows
+    environment: release
+    needs: [windows-build, windows-depends]
+    env:
+      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
+      VERSION: ${{ needs.setup-environment.outputs.VERSION }}
+      KEY_CONTAINER: ${{ vars.KEY_CONTAINER }}
+    steps:
+      - uses: actions/checkout@v4
+      # - uses: google-github-actions/auth@v2
+      #   with:
+      #     project_id: ollama
+      #     credentials_json: ${{ secrets.GOOGLE_SIGNING_CREDENTIALS }}
+      # - run: |
+      #     $ErrorActionPreference = "Stop"
+      #     Invoke-WebRequest -Uri "https://go.microsoft.com/fwlink/p/?LinkId=323507" -OutFile "${{ runner.temp }}\sdksetup.exe"
+      #     Start-Process "${{ runner.temp }}\sdksetup.exe" -ArgumentList @("/q") -NoNewWindow -Wait
+
+      #     Invoke-WebRequest -Uri "https://github.com/GoogleCloudPlatform/kms-integrations/releases/download/cng-v1.0/kmscng-1.0-windows-amd64.zip" -OutFile "${{ runner.temp }}\plugin.zip"
+      #     Expand-Archive -Path "${{ runner.temp }}\plugin.zip" -DestinationPath "${{ runner.temp }}\plugin\"
+      #     & "${{ runner.temp }}\plugin\*\kmscng.msi" /quiet
+
+      #     echo "${{ vars.OLLAMA_CERT }}" >ollama_inc.crt
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: depends-windows*
+          path: dist
+          merge-multiple: true
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: build-windows*
+          path: dist
+          merge-multiple: true
+      - name: Log dist contents after download
+        run: |
+          gci -path .\dist -recurse
+      - run: |
+          ./scripts/build_windows.ps1 deps sign installer zip
+      - name: Log contents after build
+        run: |
+          gci -path .\dist -Recurse -File | ForEach-Object { get-filehash -path $_.FullName -Algorithm SHA256 } | format-list
+      - uses: actions/upload-artifact@v4
+        with:
+          name: bundles-windows
+          path: |
+            dist/*.zip
+            dist/OllamaSetup.exe
 
   linux-build:
     strategy:
@@ -288,7 +363,7 @@ jobs:
           done
       - uses: actions/upload-artifact@v4
         with:
-          name: dist-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.target }}
+          name: bundles-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.target }}
           path: |
             *.tgz
 
@@ -344,7 +419,7 @@ jobs:
         with:
           context: .
           platforms: ${{ matrix.os }}/${{ matrix.arch }}
-          target: ${{ matrix.target }}
+          target: ${{ matrix.preset }}
           build-args: ${{ matrix.build-args }}
           outputs: type=image,name=${{ vars.DOCKER_REPO }},push-by-digest=true,name-canonical=true,push=true
           cache-from: type=registry,ref=${{ vars.DOCKER_REPO }}:latest
@@ -393,17 +468,28 @@ jobs:
           docker buildx imagetools inspect ${{ vars.DOCKER_REPO }}:${{ steps.metadata.outputs.version }}
         working-directory: ${{ runner.temp }}
 
-  # Trigger downstream release process
-  trigger:
+  # Final release process
+  release:
     runs-on: ubuntu-latest
     environment: release
-    needs: [darwin-build, windows-build, windows-depends, linux-build]
+    needs: [darwin-build, windows-app, linux-build]
     permissions:
       contents: write
     env:
       GH_TOKEN: ${{ github.token }}
     steps:
       - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: bundles-*
+          path: dist
+          merge-multiple: true
+      - name: Log dist contents
+        run: |
+          ls -l dist/
+      - name: Generate checksum file
+        run: find . -type f -not -name 'sha256sum.txt' | xargs sha256sum | tee sha256sum.txt
+        working-directory: dist
       - name: Create or update Release for tag
         run: |
           RELEASE_VERSION="$(echo ${GITHUB_REF_NAME} | cut -f1 -d-)"
@@ -420,12 +506,17 @@ jobs:
               --generate-notes \
               --prerelease
           fi
-      - name: Trigger downstream release process
+      - name: Upload release artifacts
         run: |
-          curl -L \
-            -X POST \
-            -H "Accept: application/vnd.github+json" \
-            -H "Authorization: Bearer ${{ secrets.RELEASE_TOKEN }}" \
-            -H "X-GitHub-Api-Version: 2022-11-28" \
-            https://api.github.com/repos/ollama/${{ vars.RELEASE_REPO }}/dispatches \
-            -d "{\"event_type\": \"trigger-workflow\", \"client_payload\": {\"run_id\": \"${GITHUB_RUN_ID}\", \"version\": \"${GITHUB_REF_NAME#v}\", \"origin\": \"${GITHUB_REPOSITORY}\", \"publish\": \"1\"}}"
+          pids=()
+          for payload in dist/*.txt dist/*.zip dist/*.tgz dist/*.exe dist/*.dmg ; do
+            echo "Uploading $payload"
+            gh release upload ${GITHUB_REF_NAME} $payload --clobber &
+            pids[$!]=$!
+            sleep 1
+          done
+          echo "Waiting for uploads to complete"
+          for pid in "${pids[*]}"; do
+            wait $pid
+          done
+          echo "done"

.github/workflows/test.yaml

@@ -200,51 +200,26 @@ jobs:
     runs-on: ${{ matrix.os }}
     env:
       CGO_ENABLED: '1'
-      GOEXPERIMENT: 'synctest'
     steps:
-      - name: checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # 4.2.2
-
-      - name: cache restore
-        uses: actions/cache/restore@1bd1e32a3bdc45362d1e726936510720a7c30a57 # v4.2.0
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
         with:
-          # Note: unlike the other setups, this is only grabbing the mod download
-          # cache, rather than the whole mod directory, as the download cache
-          # contains zips that can be unpacked in parallel faster than they can be
-          # fetched and extracted by tar
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod/cache
-            ~\AppData\Local\go-build
-          # NOTE: The -3- here should be incremented when the scheme of data to be
-          # cached changes (e.g. path above changes).
-          key: ${{ github.job }}-${{ runner.os }}-${{ matrix.goarch }}-${{ matrix.buildflags }}-go-3-${{ hashFiles('**/go.sum') }}-${{ github.run_id }}
-          restore-keys: |
-            ${{ github.job }}-${{ runner.os }}-${{ matrix.goarch }}-${{ matrix.buildflags }}-go-3-${{ hashFiles('**/go.sum') }}
-            ${{ github.job }}-${{ runner.os }}-${{ matrix.goarch }}-${{ matrix.buildflags }}-go-3-
-
-      - name: Setup Go
-        uses: actions/setup-go@v5
+          go-version-file: 'go.mod'
+      - uses: actions/setup-node@v4
         with:
-          # The caching strategy of setup-go is less than ideal, and wastes
-          # time by not saving artifacts due to small failures like the linter
-          # complaining, etc. This means subsequent have to rebuild their world
-          # again until all checks pass. For instance, if you mispell a word,
-          # you're punished until you fix it. This is more hostile than
-          # helpful.
-          cache: false
-
-          go-version-file: go.mod
-
-      # It is tempting to run this in a platform independent way, but the past
-      # shows this codebase will see introductions of platform specific code
-      # generation, and so we need to check this per platform to ensure we
-      # don't abuse go generate on specific platforms.
-      - name: check that 'go generate' is clean
-        if: always()
+          node-version: '20'
+      - name: Install UI dependencies
+        working-directory: ./app/ui/app
+        run: npm ci
+      - name: Install tscriptify
         run: |
-          go generate ./...
-          git diff --name-only --exit-code || (echo "Please run 'go generate ./...'." && exit 1)
+          go install github.com/tkrajina/typescriptify-golang-structs/tscriptify@latest
+      - name: Run UI tests
+        if: ${{ startsWith(matrix.os, 'ubuntu') }}
+        working-directory: ./app/ui/app
+        run: npm test
+      - name: Run go generate
+        run: go generate ./...
 
       - name: go test
         if: always()
@@ -257,26 +232,6 @@ jobs:
         with:
           args: --timeout 10m0s -v
 
-      - name: cache save
-        # Always save the cache, even if the job fails. The artifacts produced
-        # during the building of test binaries are not all for naught. They can
-        # be used to speed up subsequent runs.
-        if: always()
-
-        uses: actions/cache/save@1bd1e32a3bdc45362d1e726936510720a7c30a57 # v4.2.0
-        with:
-          # Note: unlike the other setups, this is only grabbing the mod download
-          # cache, rather than the whole mod directory, as the download cache
-          # contains zips that can be unpacked in parallel faster than they can be
-          # fetched and extracted by tar
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod/cache
-            ~\AppData\Local\go-build
-          # NOTE: The -3- here should be incremented when the scheme of data to be
-          # cached changes (e.g. path above changes).
-          key: ${{ github.job }}-${{ runner.os }}-${{ matrix.goarch }}-${{ matrix.buildflags }}-go-3-${{ hashFiles('**/go.sum') }}-${{ github.run_id }}
-
   patches:
     runs-on: ubuntu-latest
     steps:

CMakePresets.json

@@ -23,7 +23,8 @@
       "inherits": [ "CUDA" ],
       "cacheVariables": {
         "CMAKE_CUDA_ARCHITECTURES": "50-virtual;60-virtual;61-virtual;70-virtual;75-virtual;80-virtual;86-virtual;87-virtual;89-virtual;90-virtual",
-        "CMAKE_CUDA_FLAGS": "-Wno-deprecated-gpu-targets -t 2"
+        "CMAKE_CUDA_FLAGS": "-Wno-deprecated-gpu-targets -t 2",
+        "OLLAMA_RUNNER_DIR": "cuda_v11"
       }
     },
     {
@@ -31,7 +32,8 @@
       "inherits": [ "CUDA" ],
       "cacheVariables": {
         "CMAKE_CUDA_ARCHITECTURES": "50;52;60;61;70;75;80;86;89;90;90a;120",
-        "CMAKE_CUDA_FLAGS": "-Wno-deprecated-gpu-targets -t 2"
+        "CMAKE_CUDA_FLAGS": "-Wno-deprecated-gpu-targets -t 2",
+        "OLLAMA_RUNNER_DIR": "cuda_v12"
       }
     },
     {
@@ -39,21 +41,24 @@
       "inherits": [ "CUDA" ],
       "cacheVariables": {
         "CMAKE_CUDA_ARCHITECTURES": "75-virtual;80-virtual;86-virtual;87-virtual;89-virtual;90-virtual;90a-virtual;100-virtual;103-virtual;110-virtual;120-virtual;121-virtual",
-        "CMAKE_CUDA_FLAGS": "-t 2"
+        "CMAKE_CUDA_FLAGS": "-t 2",
+        "OLLAMA_RUNNER_DIR": "cuda_v13"
       }
     },
     {
       "name": "JetPack 5",
       "inherits": [ "CUDA" ],
       "cacheVariables": {
-        "CMAKE_CUDA_ARCHITECTURES": "72;87"
+        "CMAKE_CUDA_ARCHITECTURES": "72;87",
+        "OLLAMA_RUNNER_DIR": "cuda_jetpack5"
       }
     },
     {
       "name": "JetPack 6",
       "inherits": [ "CUDA" ],
       "cacheVariables": {
-        "CMAKE_CUDA_ARCHITECTURES": "87"
+        "CMAKE_CUDA_ARCHITECTURES": "87",
+        "OLLAMA_RUNNER_DIR": "cuda_jetpack6"
       }
     },
     {
@@ -68,12 +73,16 @@
       "inherits": [ "ROCm" ],
       "cacheVariables": {
         "CMAKE_HIP_FLAGS": "-parallel-jobs=4",
-        "AMDGPU_TARGETS": "gfx940;gfx941;gfx942;gfx1010;gfx1012;gfx1030;gfx1100;gfx1101;gfx1102;gfx1151;gfx1200;gfx1201;gfx908:xnack-;gfx90a:xnack+;gfx90a:xnack-"
+        "AMDGPU_TARGETS": "gfx940;gfx941;gfx942;gfx1010;gfx1012;gfx1030;gfx1100;gfx1101;gfx1102;gfx1151;gfx1200;gfx1201;gfx908:xnack-;gfx90a:xnack+;gfx90a:xnack-",
+        "OLLAMA_RUNNER_DIR": "rocm"
       }
     },
     {
       "name": "Vulkan",
-      "inherits": [ "Default" ]
+      "inherits": [ "Default" ],
+      "cacheVariables": {
+        "OLLAMA_RUNNER_DIR": "vulkan"
+      }
     }
   ],
   "buildPresets": [

Dockerfile

@@ -58,7 +58,7 @@ RUN dnf install -y cuda-toolkit-${CUDA11VERSION//./-}
 ENV PATH=/usr/local/cuda-11/bin:$PATH
 ARG PARALLEL
 RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'CUDA 11' -DOLLAMA_RUNNER_DIR="cuda_v11" \
+    cmake --preset 'CUDA 11' \
         && cmake --build --parallel ${PARALLEL} --preset 'CUDA 11' \
         && cmake --install build --component CUDA --strip --parallel ${PARALLEL}
 
@@ -68,7 +68,7 @@ RUN dnf install -y cuda-toolkit-${CUDA12VERSION//./-}
 ENV PATH=/usr/local/cuda-12/bin:$PATH
 ARG PARALLEL
 RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'CUDA 12' -DOLLAMA_RUNNER_DIR="cuda_v12"\
+    cmake --preset 'CUDA 12' \
         && cmake --build --parallel ${PARALLEL} --preset 'CUDA 12' \
         && cmake --install build --component CUDA --strip --parallel ${PARALLEL}
 
@@ -79,7 +79,7 @@ RUN dnf install -y cuda-toolkit-${CUDA13VERSION//./-}
 ENV PATH=/usr/local/cuda-13/bin:$PATH
 ARG PARALLEL
 RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'CUDA 13' -DOLLAMA_RUNNER_DIR="cuda_v13" \
+    cmake --preset 'CUDA 13' \
         && cmake --build --parallel ${PARALLEL} --preset 'CUDA 13' \
         && cmake --install build --component CUDA --strip --parallel ${PARALLEL}
 
@@ -88,7 +88,7 @@ FROM base AS rocm-6
 ENV PATH=/opt/rocm/hcc/bin:/opt/rocm/hip/bin:/opt/rocm/bin:/opt/rocm/hcc/bin:$PATH
 ARG PARALLEL
 RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'ROCm 6' -DOLLAMA_RUNNER_DIR="rocm" \
+    cmake --preset 'ROCm 6' \
         && cmake --build --parallel ${PARALLEL} --preset 'ROCm 6' \
         && cmake --install build --component HIP --strip --parallel ${PARALLEL}
 RUN rm -f dist/lib/ollama/rocm/rocblas/library/*gfx90[06]*
@@ -101,7 +101,7 @@ COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 ARG PARALLEL
 RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'JetPack 5' -DOLLAMA_RUNNER_DIR="cuda_jetpack5" \
+    cmake --preset 'JetPack 5' \
         && cmake --build --parallel ${PARALLEL} --preset 'JetPack 5' \
         && cmake --install build --component CUDA --strip --parallel ${PARALLEL}
 
@@ -113,13 +113,13 @@ COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 ARG PARALLEL
 RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'JetPack 6' -DOLLAMA_RUNNER_DIR="cuda_jetpack6" \
+    cmake --preset 'JetPack 6' \
         && cmake --build --parallel ${PARALLEL} --preset 'JetPack 6' \
         && cmake --install build --component CUDA --strip --parallel ${PARALLEL}
 
 FROM base AS vulkan
 RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'Vulkan' -DOLLAMA_RUNNER_DIR="vulkan" \
+    cmake --preset 'Vulkan' \
         && cmake --build --parallel --preset 'Vulkan' \
         && cmake --install build --component Vulkan --strip --parallel 8 
 

app/.gitignore

 ollama.syso
+*.crt
+*.exe
+/app/app
+/app/squirrel
+ollama
+*cover*
+.vscode
+.env
+.DS_Store
+.claude

app/README.md

-# Ollama App
+# Ollama for macOS and Windows
 
-## Linux
+## Download
 
-TODO
+- [macOS](https://github.com/ollama/app/releases/download/latest/Ollama.dmg)
+- [Windows](https://github.com/ollama/app/releases/download/latest/OllamaSetup.exe)
 
-## MacOS
+## Development
 
-TODO
+### Desktop App
 
-## Windows
+```bash
+go generate ./... &&
+go run ./cmd/app
+```
+
+### UI Development
+
+#### Setup
+
+Install required tools:
+
+```bash
+go install github.com/tkrajina/typescriptify-golang-structs/tscriptify@latest
+```
+
+#### Develop UI (Development Mode)
+
+1. Start the React development server (with hot-reload):
+
+```bash
+cd ui/app
+npm install
+npm run dev
+```
+
+2. In a separate terminal, run the Ollama app with the `-dev` flag:
+
+```bash
+go generate ./... &&
+OLLAMA_DEBUG=1 go run ./cmd/app -dev
+```
+
+The `-dev` flag enables:
+
+- Loading the UI from the Vite dev server at http://localhost:5173
+- Fixed UI server port at http://127.0.0.1:3001 for API requests
+- CORS headers for cross-origin requests
+- Hot-reload support for UI development
+
+#### Run Storybook
+
+Inside the `ui/app` directory, run:
+
+```bash
+npm run storybook
+```
+
+For now we're writing stories as siblings of the component they're testing. So for example, `src/components/Message.stories.tsx` is the story for `src/components/Message.tsx`.
+
+## Build
+
+
+### Windows
 
-If you want to build the installer, youll need to install
 - https://jrsoftware.org/isinfo.php
 
 
-In the top directory of this repo, run the following powershell script
-to build the ollama CLI, ollama app, and ollama installer.
+**Dependencies** - either build a local copy of ollama, or use a github release
+```powershell
+# Local dependencies
+.\scripts\deps_local.ps1
+
+# Release dependencies
+.\scripts\deps_release.ps1 0.6.8
+```
 
+**Build**
 ```powershell
-powershell -ExecutionPolicy Bypass -File .\scripts\build_windows.ps1
+.\scripts\build_windows.ps1
+```
+
+### macOS
+
+CI builds with Xcode 14.1 for OS compatibility prior to v13.  If you want to manually build v11+ support, you can download the older Xcode [here](https://developer.apple.com/services-account/download?path=/Developer_Tools/Xcode_14.1/Xcode_14.1.xip), extract, then `mv ./Xcode.app /Applications/Xcode_14.1.0.app` then activate with:
+
+```
+export CGO_CFLAGS=-mmacosx-version-min=12.0
+export CGO_CXXFLAGS=-mmacosx-version-min=12.0
+export CGO_LDFLAGS=-mmacosx-version-min=12.0
+export SDKROOT=/Applications/Xcode_14.1.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk
+export DEVELOPER_DIR=/Applications/Xcode_14.1.0.app/Contents/Developer
+```
+
+**Dependencies** - either build a local copy of Ollama, or use a GitHub release:
+```sh
+# Local dependencies
+./scripts/deps_local.sh
+
+# Release dependencies
+./scripts/deps_release.sh 0.6.8
+```
+
+**Build**
+```sh
+./scripts/build_darwin.sh
 ```

app/assets/assets.go

+//go:build windows || darwin
+
 package assets
 
 import (

app/auth/connect.go

+//go:build windows || darwin
+
+package auth
+
+import (
+	"encoding/base64"
+	"fmt"
+	"net/url"
+	"os"
+
+	"github.com/ollama/ollama/auth"
+)
+
+// BuildConnectURL generates the connect URL with the public key and device name
+func BuildConnectURL(baseURL string) (string, error) {
+	pubKey, err := auth.GetPublicKey()
+	if err != nil {
+		return "", fmt.Errorf("failed to get public key: %w", err)
+	}
+
+	encodedKey := base64.RawURLEncoding.EncodeToString([]byte(pubKey))
+	hostname, _ := os.Hostname()
+	encodedDevice := url.QueryEscape(hostname)
+
+	return fmt.Sprintf("%s/connect?name=%s&key=%s&launch=true", baseURL, encodedDevice, encodedKey), nil
+}

app/cmd/app/AppDelegate.h

+#import <Cocoa/Cocoa.h>
+
+@interface AppDelegate : NSObject <NSApplicationDelegate>
+
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification;
+
+@end
\ No newline at end of file

app/cmd/app/app.go

+//go:build windows || darwin
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/ollama/ollama/app/auth"
+	"github.com/ollama/ollama/app/logrotate"
+	"github.com/ollama/ollama/app/server"
+	"github.com/ollama/ollama/app/store"
+	"github.com/ollama/ollama/app/tools"
+	"github.com/ollama/ollama/app/ui"
+	"github.com/ollama/ollama/app/updater"
+	"github.com/ollama/ollama/app/version"
+)
+
+var (
+	wv           = &Webview{}
+	uiServerPort int
+)
+
+var debug = strings.EqualFold(os.Getenv("OLLAMA_DEBUG"), "true") || os.Getenv("OLLAMA_DEBUG") == "1"
+
+var (
+	fastStartup = false
+	devMode     = false
+)
+
+type appMove int
+
+const (
+	CannotMove appMove = iota
+	UserDeclinedMove
+	MoveCompleted
+	AlreadyMoved
+	LoginSession
+	PermissionDenied
+	MoveError
+)
+
+func main() {
+	startHidden := false
+	var urlSchemeRequest string
+	if len(os.Args) > 1 {
+		for _, arg := range os.Args {
+			// Handle URL scheme requests (Windows)
+			if strings.HasPrefix(arg, "ollama://") {
+				urlSchemeRequest = arg
+				slog.Info("received URL scheme request", "url", arg)
+				continue
+			}
+			switch arg {
+			case "serve":
+				fmt.Fprintln(os.Stderr, "serve command not supported, use ollama")
+				os.Exit(1)
+			case "version", "-v", "--version":
+				fmt.Println(version.Version)
+				os.Exit(0)
+			case "background":
+				// When running the process in this "background" mode, we spawn a
+				// child process for the main app.  This is necessary so the
+				// "Allow in the Background" setting in MacOS can be unchecked
+				// without breaking the main app.  Two copies of the app are
+				// present in the bundle, one for the main app and one for the
+				// background initiator.
+				fmt.Fprintln(os.Stdout, "starting in background")
+				runInBackground()
+				os.Exit(0)
+			case "hidden", "-j", "--hide":
+				// startHidden suppresses the UI on startup, and can be triggered multiple ways
+				// On windows, path based via login startup detection
+				// On MacOS via [NSApp isHidden] from `open -j -a /Applications/Ollama.app` or equivalent
+				// On both via the "hidden" command line argument
+				startHidden = true
+			case "--fast-startup":
+				// Skip optional steps like pending updates to start quickly for immediate use
+				fastStartup = true
+			case "-dev", "--dev":
+				// Development mode: use local dev server and enable CORS
+				devMode = true
+			}
+		}
+	}
+
+	level := slog.LevelInfo
+	if debug {
+		level = slog.LevelDebug
+	}
+
+	logrotate.Rotate(appLogPath)
+	if _, err := os.Stat(filepath.Dir(appLogPath)); errors.Is(err, os.ErrNotExist) {
+		if err := os.MkdirAll(filepath.Dir(appLogPath), 0o755); err != nil {
+			slog.Error(fmt.Sprintf("failed to create server log dir %v", err))
+			return
+		}
+	}
+
+	var logFile io.Writer
+	var err error
+	logFile, err = os.OpenFile(appLogPath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0o755)
+	if err != nil {
+		slog.Error(fmt.Sprintf("failed to create server log %v", err))
+		return
+	}
+	// Detect if we're a GUI app on windows, and if not, send logs to console as well
+	if os.Stderr.Fd() != 0 {
+		// Console app detected
+		logFile = io.MultiWriter(os.Stderr, logFile)
+	}
+
+	handler := slog.NewTextHandler(logFile, &slog.HandlerOptions{
+		Level:     level,
+		AddSource: true,
+		ReplaceAttr: func(_ []string, attr slog.Attr) slog.Attr {
+			if attr.Key == slog.SourceKey {
+				source := attr.Value.Any().(*slog.Source)
+				source.File = filepath.Base(source.File)
+			}
+			return attr
+		},
+	})
+
+	slog.SetDefault(slog.New(handler))
+	logStartup()
+
+	// On Windows, check if another instance is running and send URL to it
+	// Do this after logging is set up so we can debug issues
+	if runtime.GOOS == "windows" && urlSchemeRequest != "" {
+		slog.Debug("checking for existing instance", "url", urlSchemeRequest)
+		if checkAndHandleExistingInstance(urlSchemeRequest) {
+			// The function will exit if it successfully sends to another instance
+			// If we reach here, we're the first/only instance
+		} else {
+			// No existing instance found, handle the URL scheme in this instance
+			go func() {
+				handleURLSchemeInCurrentInstance(urlSchemeRequest)
+			}()
+		}
+	}
+
+	if u := os.Getenv("OLLAMA_UPDATE_URL"); u != "" {
+		updater.UpdateCheckURLBase = u
+	}
+
+	// Detect if this is a first start after an upgrade, in
+	// which case we need to do some cleanup
+	var skipMove bool
+	if _, err := os.Stat(updater.UpgradeMarkerFile); err == nil {
+		slog.Debug("first start after upgrade")
+		err = updater.DoPostUpgradeCleanup()
+		if err != nil {
+			slog.Error("failed to cleanup prior version", "error", err)
+		}
+		// We never prompt to move the app after an upgrade
+		skipMove = true
+		// Start hidden after updates to prevent UI from opening automatically
+		startHidden = true
+	}
+
+	if !skipMove && !fastStartup {
+		if maybeMoveAndRestart() == MoveCompleted {
+			return
+		}
+	}
+
+	// Check if another instance is already running
+	// On Windows, focus the existing instance; on other platforms, kill it
+	handleExistingInstance(startHidden)
+
+	// on macOS, offer the user to create a symlink
+	// from /usr/local/bin/ollama to the app bundle
+	installSymlink()
+
+	var ln net.Listener
+	if devMode {
+		// Use a fixed port in dev mode for predictable API access
+		ln, err = net.Listen("tcp", "127.0.0.1:3001")
+	} else {
+		ln, err = net.Listen("tcp", "127.0.0.1:0")
+	}
+	if err != nil {
+		slog.Error("failed to find available port", "error", err)
+		return
+	}
+
+	port := ln.Addr().(*net.TCPAddr).Port
+	token := uuid.NewString()
+	wv.port = port
+	wv.token = token
+	uiServerPort = port
+
+	st := &store.Store{}
+
+	// Enable CORS in development mode
+	if devMode {
+		os.Setenv("OLLAMA_CORS", "1")
+
+		// Check if Vite dev server is running on port 5173
+		var conn net.Conn
+		var err error
+		for _, addr := range []string{"127.0.0.1:5173", "localhost:5173"} {
+			conn, err = net.DialTimeout("tcp", addr, 2*time.Second)
+			if err == nil {
+				conn.Close()
+				break
+			}
+		}
+
+		if err != nil {
+			slog.Error("Vite dev server not running on port 5173")
+			fmt.Fprintln(os.Stderr, "Error: Vite dev server is not running on port 5173")
+			fmt.Fprintln(os.Stderr, "Please run 'npm run dev' in the ui/app directory to start the UI in development mode")
+			os.Exit(1)
+		}
+	}
+
+	// Initialize tools registry
+	toolRegistry := tools.NewRegistry()
+	slog.Info("initialized tools registry", "tool_count", len(toolRegistry.List()))
+
+	// ctx is the app-level context that will be used to stop the app
+	ctx, cancel := context.WithCancel(context.Background())
+
+	// octx is the ollama server context that will be used to stop the ollama server
+	octx, ocancel := context.WithCancel(ctx)
+
+	// TODO (jmorganca): instead we should instantiate the
+	// webview with the store instead of assigning it here, however
+	// making the webview a global variable is easier for now
+	wv.Store = st
+	done := make(chan error, 1)
+	osrv := server.New(st, devMode)
+	go func() {
+		slog.Info("starting ollama server")
+		done <- osrv.Run(octx)
+	}()
+
+	uiServer := ui.Server{
+		Token: token,
+		Restart: func() {
+			ocancel()
+			<-done
+			octx, ocancel = context.WithCancel(ctx)
+			go func() {
+				done <- osrv.Run(octx)
+			}()
+		},
+		Store:        st,
+		ToolRegistry: toolRegistry,
+		Dev:          devMode,
+		Logger:       slog.Default(),
+	}
+
+	srv := &http.Server{
+		Handler: uiServer.Handler(),
+	}
+
+	if _, err := uiServer.UserData(ctx); err != nil {
+		slog.Warn("failed to load user data", "error", err)
+	}
+
+	// Start the UI server
+	slog.Info("starting ui server", "port", port)
+	go func() {
+		slog.Debug("starting ui server on port", "port", port)
+		err = srv.Serve(ln)
+		if err != nil && !errors.Is(err, http.ErrServerClosed) {
+			slog.Warn("desktop server", "error", err)
+		}
+		slog.Debug("background desktop server done")
+	}()
+
+	updater := &updater.Updater{Store: st}
+	updater.StartBackgroundUpdaterChecker(ctx, UpdateAvailable)
+
+	hasCompletedFirstRun, err := st.HasCompletedFirstRun()
+	if err != nil {
+		slog.Error("failed to load has completed first run", "error", err)
+	}
+
+	if !hasCompletedFirstRun {
+		err = st.SetHasCompletedFirstRun(true)
+		if err != nil {
+			slog.Error("failed to set has completed first run", "error", err)
+		}
+	}
+
+	// capture SIGINT and SIGTERM signals and gracefully shutdown the app
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-signals
+		slog.Info("received SIGINT or SIGTERM signal, shutting down")
+		quit()
+	}()
+
+	if urlSchemeRequest != "" {
+		go func() {
+			handleURLSchemeInCurrentInstance(urlSchemeRequest)
+		}()
+	} else {
+		slog.Debug("no URL scheme request to handle")
+	}
+
+	osRun(cancel, hasCompletedFirstRun, startHidden)
+
+	slog.Info("shutting down desktop server")
+	if err := srv.Close(); err != nil {
+		slog.Warn("error shutting down desktop server", "error", err)
+	}
+
+	slog.Info("shutting down ollama server")
+	cancel()
+	<-done
+}
+
+func startHiddenTasks() {
+	// If an upgrade is ready and we're in hidden mode, perform it at startup.
+	// If we're not in hidden mode, we want to start as fast as possible and not
+	// slow the user down with an upgrade.
+	if updater.IsUpdatePending() {
+		if fastStartup {
+			// CLI triggered app startup use-case
+			slog.Info("deferring pending update for fast startup")
+		} else {
+			if err := updater.DoUpgradeAtStartup(); err != nil {
+				slog.Info("unable to perform upgrade at startup", "error", err)
+				// Make sure the restart to upgrade menu shows so we can attempt an interactive upgrade to get authorization
+				UpdateAvailable("")
+			} else {
+				slog.Debug("launching new version...")
+				// TODO - consider a timer that aborts if this takes too long and we haven't been killed yet...
+				LaunchNewApp()
+				os.Exit(0)
+			}
+		}
+	}
+}
+
+func checkUserLoggedIn(uiServerPort int) bool {
+	if uiServerPort == 0 {
+		slog.Debug("UI server not ready yet, skipping auth check")
+		return false
+	}
+
+	resp, err := http.Get(fmt.Sprintf("http://127.0.0.1:%d/api/v1/me", uiServerPort))
+	if err != nil {
+		slog.Debug("failed to call local auth endpoint", "error", err)
+		return false
+	}
+	defer resp.Body.Close()
+
+	// Check if the response is successful
+	if resp.StatusCode != http.StatusOK {
+		slog.Debug("auth endpoint returned non-OK status", "status", resp.StatusCode)
+		return false
+	}
+
+	var user struct {
+		ID   string `json:"id"`
+		Name string `json:"name"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
+		slog.Debug("failed to parse user response", "error", err)
+		return false
+	}
+
+	// Verify we have a valid user with an ID and name
+	if user.ID == "" || user.Name == "" {
+		slog.Debug("user response missing required fields", "id", user.ID, "name", user.Name)
+		return false
+	}
+
+	slog.Debug("user is logged in", "user_id", user.ID, "user_name", user.Name)
+	return true
+}
+
+// handleConnectURLScheme fetches the connect URL and opens it in the browser
+func handleConnectURLScheme() {
+	if checkUserLoggedIn(uiServerPort) {
+		slog.Info("user is already logged in, opening settings instead")
+		sendUIRequestMessage("/")
+		return
+	}
+
+	connectURL, err := auth.BuildConnectURL("https://ollama.com")
+	if err != nil {
+		slog.Error("failed to build connect URL", "error", err)
+		openInBrowser("https://ollama.com/connect")
+		return
+	}
+
+	openInBrowser(connectURL)
+}
+
+// openInBrowser opens the specified URL in the default browser
+func openInBrowser(url string) {
+	var cmd string
+	var args []string
+
+	switch runtime.GOOS {
+	case "windows":
+		cmd = "rundll32"
+		args = []string{"url.dll,FileProtocolHandler", url}
+	case "darwin":
+		cmd = "open"
+		args = []string{url}
+	default: // "linux", "freebsd", "openbsd", "netbsd"... should not reach here
+		slog.Warn("unsupported OS for openInBrowser", "os", runtime.GOOS)
+	}
+
+	slog.Info("executing browser command", "cmd", cmd, "args", args)
+	if err := exec.Command(cmd, args...).Start(); err != nil {
+		slog.Error("failed to open URL in browser", "url", url, "cmd", cmd, "args", args, "error", err)
+	}
+}
+
+// parseURLScheme parses an ollama:// URL and returns whether it's a connect URL and the UI path
+func parseURLScheme(urlSchemeRequest string) (isConnect bool, uiPath string, err error) {
+	parsedURL, err := url.Parse(urlSchemeRequest)
+	if err != nil {
+		return false, "", err
+	}
+
+	// Check if this is a connect URL
+	if parsedURL.Host == "connect" || strings.TrimPrefix(parsedURL.Path, "/") == "connect" {
+		return true, "", nil
+	}
+
+	// Extract the UI path
+	path := "/"
+	if parsedURL.Path != "" && parsedURL.Path != "/" {
+		// For URLs like ollama:///settings, use the path directly
+		path = parsedURL.Path
+	} else if parsedURL.Host != "" {
+		// For URLs like ollama://settings (without triple slash),
+		// the "settings" part is parsed as the host, not the path.
+		// We need to convert it to a path by prepending "/"
+		// This also handles ollama://settings/ where Windows adds a trailing slash
+		path = "/" + parsedURL.Host
+	}
+
+	return false, path, nil
+}
+
+// handleURLSchemeInCurrentInstance processes URL scheme requests in the current instance
+func handleURLSchemeInCurrentInstance(urlSchemeRequest string) {
+	isConnect, uiPath, err := parseURLScheme(urlSchemeRequest)
+	if err != nil {
+		slog.Error("failed to parse URL scheme request", "url", urlSchemeRequest, "error", err)
+		return
+	}
+
+	if isConnect {
+		handleConnectURLScheme()
+	} else {
+		sendUIRequestMessage(uiPath)
+	}
+}

app/cmd/app/app_darwin.go

+//go:build windows || darwin
+
+package main
+
+// #cgo CFLAGS: -x objective-c
+// #cgo LDFLAGS: -framework Webkit -framework Cocoa -framework LocalAuthentication -framework ServiceManagement
+// #include "app_darwin.h"
+// #include "../../updater/updater_darwin.h"
+// typedef const char cchar_t;
+import "C"
+
+import (
+	"log/slog"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+	"unsafe"
+
+	"github.com/ollama/ollama/app/updater"
+	"github.com/ollama/ollama/app/version"
+)
+
+var ollamaPath = func() string {
+	if updater.BundlePath != "" {
+		return filepath.Join(updater.BundlePath, "Contents", "Resources", "ollama")
+	}
+
+	pwd, err := os.Getwd()
+	if err != nil {
+		slog.Warn("failed to get pwd", "error", err)
+		return ""
+	}
+	return filepath.Join(pwd, "ollama")
+}()
+
+var (
+	isApp           = updater.BundlePath != ""
+	appLogPath      = filepath.Join(os.Getenv("HOME"), ".ollama", "logs", "app.log")
+	launchAgentPath = filepath.Join(os.Getenv("HOME"), "Library", "LaunchAgents", "com.ollama.ollama.plist")
+)
+
+// TODO(jmorganca): pre-create the window and pass
+// it to the webview instead of using the internal one
+//
+//export StartUI
+func StartUI(path *C.cchar_t) {
+	p := C.GoString(path)
+	wv.Run(p)
+	styleWindow(wv.webview.Window())
+	C.setWindowDelegate(wv.webview.Window())
+}
+
+//export ShowUI
+func ShowUI() {
+	// If webview is already running, just show the window
+	if wv.IsRunning() && wv.webview != nil {
+		showWindow(wv.webview.Window())
+	} else {
+		root := C.CString("/")
+		defer C.free(unsafe.Pointer(root))
+		StartUI(root)
+	}
+}
+
+//export StopUI
+func StopUI() {
+	wv.Terminate()
+}
+
+//export StartUpdate
+func StartUpdate() {
+	if err := updater.DoUpgrade(true); err != nil {
+		slog.Error("upgrade failed", "error", err)
+		return
+	}
+	slog.Debug("launching new version...")
+	// TODO - consider a timer that aborts if this takes too long and we haven't been killed yet...
+	LaunchNewApp()
+	// not reached if upgrade works, the new app will kill this process
+}
+
+//export darwinStartHiddenTasks
+func darwinStartHiddenTasks() {
+	startHiddenTasks()
+}
+
+func init() {
+	// Temporary code to mimic Squirrel ShipIt behavior
+	if len(os.Args) > 2 {
+		if os.Args[1] == "___launch___" {
+			path := strings.TrimPrefix(os.Args[2], "file://")
+			slog.Info("Ollama binary called as ShipIt - launching", "app", path)
+			appName := C.CString(path)
+			defer C.free(unsafe.Pointer(appName))
+			C.launchApp(appName)
+			slog.Info("other instance has been launched")
+			time.Sleep(5 * time.Second)
+			slog.Info("exiting with zero status")
+			os.Exit(0)
+		}
+	}
+}
+
+// maybeMoveAndRestart checks if we should relocate
+// and returns true if we did and should immediately exit
+func maybeMoveAndRestart() appMove {
+	if updater.BundlePath == "" {
+		// Typically developer mode with 'go run ./cmd/app'
+		return CannotMove
+	}
+	// Respect users intent if they chose "keep" vs. "replace" when dragging to Applications
+	if strings.HasPrefix(updater.BundlePath, strings.TrimSuffix(updater.SystemWidePath, filepath.Ext(updater.SystemWidePath))) {
+		return AlreadyMoved
+	}
+
+	// Ask to move to applications directory
+	status := (appMove)(C.askToMoveToApplications())
+	if status == MoveCompleted {
+		// Double check
+		if _, err := os.Stat(updater.SystemWidePath); err != nil {
+			slog.Warn("stat failure after move", "path", updater.SystemWidePath, "error", err)
+			return MoveError
+		}
+	}
+	return status
+}
+
+// handleExistingInstance handles existing instances on macOS
+func handleExistingInstance(_ bool) {
+	C.killOtherInstances()
+}
+
+func installSymlink() {
+	if !isApp {
+		return
+	}
+	cliPath := C.CString(ollamaPath)
+	defer C.free(unsafe.Pointer(cliPath))
+
+	// Check the users path first
+	cmd, _ := exec.LookPath("ollama")
+	if cmd != "" {
+		resolved, err := os.Readlink(cmd)
+		if err == nil {
+			tmp, err := filepath.Abs(resolved)
+			if err == nil {
+				resolved = tmp
+			}
+		} else {
+			resolved = cmd
+		}
+		if resolved == ollamaPath {
+			slog.Info("ollama already in users PATH", "cli", cmd)
+			return
+		}
+	}
+
+	code := C.installSymlink(cliPath)
+	if code != 0 {
+		slog.Error("Failed to install symlink")
+	}
+}
+
+func UpdateAvailable(ver string) error {
+	slog.Debug("update detected, adjusting menu")
+	// TODO (jmorganca): find a better check for development mode than checking the bundle path
+	if updater.BundlePath != "" {
+		C.updateAvailable()
+	}
+	return nil
+}
+
+func osRun(_ func(), hasCompletedFirstRun, startHidden bool) {
+	registerLaunchAgent(hasCompletedFirstRun)
+
+	// Run the native macOS app
+	// Note: this will block until the app is closed
+	slog.Debug("starting native darwin event loop")
+	C.run(C._Bool(hasCompletedFirstRun), C._Bool(startHidden))
+}
+
+func quit() {
+	C.quit()
+}
+
+func LaunchNewApp() {
+	appName := C.CString(updater.BundlePath)
+	defer C.free(unsafe.Pointer(appName))
+	C.launchApp(appName)
+}
+
+// Send a request to the main app thread to load a UI page
+func sendUIRequestMessage(path string) {
+	p := C.CString(path)
+	defer C.free(unsafe.Pointer(p))
+	C.uiRequest(p)
+}
+
+func registerLaunchAgent(hasCompletedFirstRun bool) {
+	// Remove any stale Login Item registrations
+	C.unregisterSelfFromLoginItem()
+
+	C.registerSelfAsLoginItem(C._Bool(hasCompletedFirstRun))
+}
+
+func logStartup() {
+	appPath := updater.BundlePath
+	if appPath == updater.SystemWidePath {
+		// Detect sandboxed scenario
+		exe, err := os.Executable()
+		if err == nil {
+			p := filepath.Dir(exe)
+			if filepath.Base(p) == "MacOS" {
+				p = filepath.Dir(filepath.Dir(p))
+				if p != appPath {
+					slog.Info("starting sandboxed Ollama", "app", appPath, "sandbox", p)
+					return
+				}
+			}
+		}
+	}
+	slog.Info("starting Ollama", "app", appPath, "version", version.Version, "OS", updater.UserAgentOS)
+}
+
+func hideWindow(ptr unsafe.Pointer) {
+	C.hideWindow(C.uintptr_t(uintptr(ptr)))
+}
+
+func showWindow(ptr unsafe.Pointer) {
+	C.showWindow(C.uintptr_t(uintptr(ptr)))
+}
+
+func styleWindow(ptr unsafe.Pointer) {
+	C.styleWindow(C.uintptr_t(uintptr(ptr)))
+}
+
+func runInBackground() {
+	cmd := exec.Command(filepath.Join(updater.BundlePath, "Contents", "MacOS", "Ollama"), "hidden")
+	if cmd != nil {
+		err := cmd.Run()
+		if err != nil {
+			slog.Error("failed to run Ollama", "bundlePath", updater.BundlePath, "error", err)
+			os.Exit(1)
+		}
+	} else {
+		slog.Error("failed to start Ollama in background", "bundlePath", updater.BundlePath)
+		os.Exit(1)
+	}
+}
+
+func drag(ptr unsafe.Pointer) {
+	C.drag(C.uintptr_t(uintptr(ptr)))
+}
+
+func doubleClick(ptr unsafe.Pointer) {
+	C.doubleClick(C.uintptr_t(uintptr(ptr)))
+}
+
+//export handleConnectURL
+func handleConnectURL() {
+	handleConnectURLScheme()
+}
+
+// checkAndHandleExistingInstance is not needed on non-Windows platforms
+func checkAndHandleExistingInstance(_ string) bool {
+	return false
+}

app/cmd/app/app_darwin.h

+#import <Cocoa/Cocoa.h>
+#import <Security/Security.h>
+
+@interface AppDelegate : NSObject <NSApplicationDelegate>
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification;
+@end
+
+enum AppMove
+{
+    CannotMove,
+    UserDeclinedMove,
+    MoveCompleted,
+    AlreadyMoved,
+    LoginSession,
+    PermissionDenied,
+    MoveError,
+};
+
+void run(bool firstTimeRun, bool startHidden);
+void killOtherInstances();
+enum AppMove askToMoveToApplications();
+int createSymlinkWithAuthorization();
+int installSymlink(const char *cliPath);
+extern void Restart();
+// extern void Quit();
+void StartUI(const char *path);
+void ShowUI();
+void StopUI();
+void StartUpdate();
+void darwinStartHiddenTasks();
+void launchApp(const char *appPath);
+void updateAvailable();
+void quit();
+void uiRequest(char *path);
+void registerSelfAsLoginItem(bool firstTimeRun);
+void unregisterSelfFromLoginItem();
+void setWindowDelegate(void *window);
+void showWindow(uintptr_t wndPtr);
+void hideWindow(uintptr_t wndPtr);
+void styleWindow(uintptr_t wndPtr);
+void drag(uintptr_t wndPtr);
+void doubleClick(uintptr_t wndPtr);
+void handleConnectURL();

app/cmd/app/app_windows.go

+//go:build windows || darwin
+
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"log/slog"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"github.com/ollama/ollama/app/updater"
+	"github.com/ollama/ollama/app/version"
+	"github.com/ollama/ollama/app/wintray"
+	"golang.org/x/sys/windows"
+)
+
+var (
+	u32                  = windows.NewLazySystemDLL("User32.dll")
+	pBringWindowToTop    = u32.NewProc("BringWindowToTop")
+	pShowWindow          = u32.NewProc("ShowWindow")
+	pSendMessage         = u32.NewProc("SendMessageA")
+	pGetSystemMetrics    = u32.NewProc("GetSystemMetrics")
+	pGetWindowRect       = u32.NewProc("GetWindowRect")
+	pSetWindowPos        = u32.NewProc("SetWindowPos")
+	pSetForegroundWindow = u32.NewProc("SetForegroundWindow")
+	pSetActiveWindow     = u32.NewProc("SetActiveWindow")
+	pIsIconic            = u32.NewProc("IsIconic")
+
+	appPath         = filepath.Join(os.Getenv("LOCALAPPDATA"), "Programs", "Ollama")
+	appLogPath      = filepath.Join(os.Getenv("LOCALAPPDATA"), "Ollama", "app.log")
+	startupShortcut = filepath.Join(os.Getenv("APPDATA"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "Ollama.lnk")
+	ollamaPath      string
+	DesktopAppName  = "ollama app.exe"
+)
+
+func init() {
+	// With alternate install location use executable location
+	exe, err := os.Executable()
+	if err != nil {
+		slog.Warn("error discovering executable directory", "error", err)
+	} else {
+		appPath = filepath.Dir(exe)
+	}
+	ollamaPath = filepath.Join(appPath, "ollama.exe")
+
+	// Handle developer mode (go run ./cmd/app)
+	if _, err := os.Stat(ollamaPath); err != nil {
+		pwd, err := os.Getwd()
+		if err != nil {
+			slog.Warn("missing ollama.exe and failed to get pwd", "error", err)
+			return
+		}
+		distAppPath := filepath.Join(pwd, "dist", "windows-"+runtime.GOARCH)
+		distOllamaPath := filepath.Join(distAppPath, "ollama.exe")
+		if _, err := os.Stat(distOllamaPath); err == nil {
+			slog.Info("detected developer mode")
+			appPath = distAppPath
+			ollamaPath = distOllamaPath
+		}
+	}
+}
+
+func maybeMoveAndRestart() appMove {
+	return 0
+}
+
+// handleExistingInstance checks for existing instances and optionally focuses them
+func handleExistingInstance(startHidden bool) {
+	if wintray.CheckAndFocusExistingInstance(!startHidden) {
+		slog.Info("existing instance found, exiting")
+		os.Exit(0)
+	}
+}
+
+func installSymlink() {}
+
+type appCallbacks struct {
+	t        wintray.TrayCallbacks
+	shutdown func()
+}
+
+var app = &appCallbacks{}
+
+func (ac *appCallbacks) UIRun(path string) {
+	wv.Run(path)
+}
+
+func (*appCallbacks) UIShow() {
+	if wv.webview != nil {
+		showWindow(wv.webview.Window())
+	} else {
+		wv.Run("/")
+	}
+}
+
+func (*appCallbacks) UITerminate() {
+	wv.Terminate()
+}
+
+func (*appCallbacks) UIRunning() bool {
+	return wv.IsRunning()
+}
+
+func (app *appCallbacks) Quit() {
+	app.t.Quit()
+	wv.Terminate()
+}
+
+// TODO - reconcile with above for consistency between mac/windows
+func quit() {
+	wv.Terminate()
+}
+
+func (app *appCallbacks) DoUpdate() {
+	// Safeguard in case we have requests in flight that need to drain...
+	slog.Info("Waiting for server to shutdown")
+
+	app.shutdown()
+
+	if err := updater.DoUpgrade(true); err != nil {
+		slog.Warn(fmt.Sprintf("upgrade attempt failed: %s", err))
+	}
+}
+
+// HandleURLScheme implements the URLSchemeHandler interface
+func (app *appCallbacks) HandleURLScheme(urlScheme string) {
+	handleURLSchemeRequest(urlScheme)
+}
+
+// handleURLSchemeRequest processes URL scheme requests from other instances
+func handleURLSchemeRequest(urlScheme string) {
+	isConnect, uiPath, err := parseURLScheme(urlScheme)
+	if err != nil {
+		slog.Error("failed to parse URL scheme request", "url", urlScheme, "error", err)
+		return
+	}
+
+	if isConnect {
+		handleConnectURLScheme()
+	} else {
+		sendUIRequestMessage(uiPath)
+	}
+}
+
+func UpdateAvailable(ver string) error {
+	return app.t.UpdateAvailable(ver)
+}
+
+func osRun(shutdown func(), hasCompletedFirstRun, startHidden bool) {
+	var err error
+	app.shutdown = shutdown
+	app.t, err = wintray.NewTray(app)
+	if err != nil {
+		log.Fatalf("Failed to start: %s", err)
+	}
+
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
+
+	// TODO - can this be generalized?
+	go func() {
+		<-signals
+		slog.Debug("shutting down due to signal")
+		app.t.Quit()
+		wv.Terminate()
+	}()
+
+	// On windows, we run the final tasks in the main thread
+	// before starting the tray event loop.  These final tasks
+	// may trigger the UI, and must do that from the main thread.
+	if !startHidden {
+		// Determine if the process was started from a shortcut
+		// ~\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\Ollama
+		const STARTF_TITLEISLINKNAME = 0x00000800
+		var info windows.StartupInfo
+		if err := windows.GetStartupInfo(&info); err != nil {
+			slog.Debug("unable to retrieve startup info", "error", err)
+		} else if info.Flags&STARTF_TITLEISLINKNAME == STARTF_TITLEISLINKNAME {
+			linkPath := windows.UTF16PtrToString(info.Title)
+			if strings.Contains(linkPath, "Startup") {
+				startHidden = true
+			}
+		}
+	}
+	if startHidden {
+		startHiddenTasks()
+	} else {
+		ptr := wv.Run("/")
+
+		// Set the window icon using the tray icon
+		if ptr != nil {
+			iconHandle := app.t.GetIconHandle()
+			if iconHandle != 0 {
+				hwnd := uintptr(ptr)
+				const ICON_SMALL = 0
+				const ICON_BIG = 1
+				const WM_SETICON = 0x0080
+
+				pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_SMALL), uintptr(iconHandle))
+				pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_BIG), uintptr(iconHandle))
+			}
+		}
+
+		centerWindow(ptr)
+	}
+
+	if !hasCompletedFirstRun {
+		// Only create the login shortcut on first start
+		// so we can respect users deletion of the link
+		err = createLoginShortcut()
+		if err != nil {
+			slog.Warn("unable to create login shortcut", "error", err)
+		}
+	}
+
+	app.t.TrayRun() // This will block the main thread
+}
+
+func createLoginShortcut() error {
+	// The installer lays down a shortcut for us so we can copy it without
+	// having to resort to calling COM APIs to establish the shortcut
+	shortcutOrigin := filepath.Join(appPath, "lib", "Ollama.lnk")
+
+	_, err := os.Stat(startupShortcut)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			in, err := os.Open(shortcutOrigin)
+			if err != nil {
+				return fmt.Errorf("unable to open shortcut %s : %w", shortcutOrigin, err)
+			}
+			defer in.Close()
+			out, err := os.Create(startupShortcut)
+			if err != nil {
+				return fmt.Errorf("unable to open startup link %s : %w", startupShortcut, err)
+			}
+			defer out.Close()
+			_, err = io.Copy(out, in)
+			if err != nil {
+				return fmt.Errorf("unable to copy shortcut %s : %w", startupShortcut, err)
+			}
+			err = out.Sync()
+			if err != nil {
+				return fmt.Errorf("unable to sync shortcut %s : %w", startupShortcut, err)
+			}
+			slog.Info("Created Startup shortcut", "shortcut", startupShortcut)
+		} else {
+			slog.Warn("unexpected error looking up Startup shortcut", "error", err)
+		}
+	} else {
+		slog.Debug("Startup link already exists", "shortcut", startupShortcut)
+	}
+	return nil
+}
+
+// Send a request to the main app thread to load a UI page
+func sendUIRequestMessage(path string) {
+	wintray.SendUIRequestMessage(path)
+}
+
+func LaunchNewApp() {
+}
+
+func logStartup() {
+	slog.Info("starting Ollama", "app", appPath, "version", version.Version, "OS", updater.UserAgentOS)
+}
+
+const (
+	SW_HIDE        = 0  // Hides the window
+	SW_SHOW        = 5  // Shows window in its current size/position
+	SW_SHOWNA      = 8  // Shows without activating
+	SW_MINIMIZE    = 6  // Minimizes the window
+	SW_RESTORE     = 9  // Restores to previous size/position
+	SW_SHOWDEFAULT = 10 // Sets show state based on program state
+	SM_CXSCREEN    = 0
+	SM_CYSCREEN    = 1
+	HWND_TOP       = 0
+	SWP_NOSIZE     = 0x0001
+	SWP_NOMOVE     = 0x0002
+	SWP_NOZORDER   = 0x0004
+	SWP_SHOWWINDOW = 0x0040
+
+	// Menu constants
+	MF_STRING     = 0x00000000
+	MF_SEPARATOR  = 0x00000800
+	MF_GRAYED     = 0x00000001
+	TPM_RETURNCMD = 0x0100
+)
+
+// POINT structure for cursor position
+type POINT struct {
+	X int32
+	Y int32
+}
+
+// Rect structure for GetWindowRect
+type Rect struct {
+	Left   int32
+	Top    int32
+	Right  int32
+	Bottom int32
+}
+
+func centerWindow(ptr unsafe.Pointer) {
+	hwnd := uintptr(ptr)
+	if hwnd == 0 {
+		return
+	}
+
+	var rect Rect
+	pGetWindowRect.Call(hwnd, uintptr(unsafe.Pointer(&rect)))
+
+	screenWidth, _, _ := pGetSystemMetrics.Call(uintptr(SM_CXSCREEN))
+	screenHeight, _, _ := pGetSystemMetrics.Call(uintptr(SM_CYSCREEN))
+
+	windowWidth := rect.Right - rect.Left
+	windowHeight := rect.Bottom - rect.Top
+
+	x := (int32(screenWidth) - windowWidth) / 2
+	y := (int32(screenHeight) - windowHeight) / 2
+
+	// Ensure the window is not positioned off-screen
+	if x < 0 {
+		x = 0
+	}
+	if y < 0 {
+		y = 0
+	}
+
+	pSetWindowPos.Call(
+		hwnd,
+		uintptr(HWND_TOP),
+		uintptr(x),
+		uintptr(y),
+		uintptr(windowWidth),  // Keep original width
+		uintptr(windowHeight), // Keep original height
+		uintptr(SWP_SHOWWINDOW),
+	)
+}
+
+func showWindow(ptr unsafe.Pointer) {
+	hwnd := uintptr(ptr)
+	if hwnd != 0 {
+		iconHandle := app.t.GetIconHandle()
+		if iconHandle != 0 {
+			const ICON_SMALL = 0
+			const ICON_BIG = 1
+			const WM_SETICON = 0x0080
+
+			pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_SMALL), uintptr(iconHandle))
+			pSendMessage.Call(hwnd, uintptr(WM_SETICON), uintptr(ICON_BIG), uintptr(iconHandle))
+		}
+
+		// Check if window is minimized
+		isMinimized, _, _ := pIsIconic.Call(hwnd)
+		if isMinimized != 0 {
+			// Restore the window if it's minimized
+			pShowWindow.Call(hwnd, uintptr(SW_RESTORE))
+		}
+
+		// Show the window
+		pShowWindow.Call(hwnd, uintptr(SW_SHOW))
+
+		// Bring window to top
+		pBringWindowToTop.Call(hwnd)
+
+		// Force window to foreground
+		pSetForegroundWindow.Call(hwnd)
+
+		// Make it the active window
+		pSetActiveWindow.Call(hwnd)
+
+		// Ensure window is positioned on top
+		pSetWindowPos.Call(
+			hwnd,
+			uintptr(HWND_TOP),
+			0, 0, 0, 0,
+			uintptr(SWP_NOSIZE|SWP_NOMOVE|SWP_SHOWWINDOW),
+		)
+	}
+}
+
+// HideWindow hides the application window
+func hideWindow(ptr unsafe.Pointer) {
+	hwnd := uintptr(ptr)
+	if hwnd != 0 {
+		pShowWindow.Call(
+			hwnd,
+			uintptr(SW_HIDE),
+		)
+	}
+}
+
+func runInBackground() {
+	exe, err := os.Executable()
+	if err != nil {
+		slog.Error("failed to get executable path", "error", err)
+		os.Exit(1)
+	}
+	cmd := exec.Command(exe, "hidden")
+	if cmd != nil {
+		err = cmd.Run()
+		if err != nil {
+			slog.Error("failed to run Ollama", "exe", exe, "error", err)
+			os.Exit(1)
+		}
+	} else {
+		slog.Error("failed to start Ollama", "exe", exe)
+		os.Exit(1)
+	}
+}
+
+func drag(ptr unsafe.Pointer) {}
+
+func doubleClick(ptr unsafe.Pointer) {}
+
+// checkAndHandleExistingInstance checks if another instance is running and sends the URL to it
+func checkAndHandleExistingInstance(urlSchemeRequest string) bool {
+	if urlSchemeRequest == "" {
+		return false
+	}
+
+	// Try to send URL to existing instance using wintray messaging
+	if wintray.CheckAndSendToExistingInstance(urlSchemeRequest) {
+		os.Exit(0)
+		return true
+	}
+
+	// No existing instance, we'll handle it ourselves
+	return false
+}

app/cmd/app/menu.h

+#ifndef MENU_H
+#define MENU_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct
+{
+    char *label;
+    int enabled;
+    int separator;
+} menuItem;
+
+// TODO (jmorganca): these need to be forward declared in the webview.h file
+// for now but ideally they should be in this header file on windows too
+#ifndef WIN32
+int menu_get_item_count();
+void *menu_get_items();
+void menu_handle_selection(char *item);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

app/cmd/app/webview.go

+//go:build windows || darwin
+
+package main
+
+// #include "menu.h"
+import "C"
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+	"unsafe"
+
+	"github.com/ollama/ollama/app/dialog"
+	"github.com/ollama/ollama/app/store"
+	"github.com/ollama/ollama/app/webview"
+)
+
+type Webview struct {
+	port    int
+	token   string
+	webview webview.WebView
+	mutex   sync.Mutex
+
+	Store *store.Store
+}
+
+// Run initializes the webview and starts its event loop.
+// Note: this must be called from the primary app thread
+// This returns the OS native window handle to the caller
+func (w *Webview) Run(path string) unsafe.Pointer {
+	var url string
+	if devMode {
+		// In development mode, use the local dev server
+		url = fmt.Sprintf("http://localhost:5173%s", path)
+	} else {
+		url = fmt.Sprintf("http://127.0.0.1:%d%s", w.port, path)
+	}
+	w.mutex.Lock()
+	defer w.mutex.Unlock()
+
+	if w.webview == nil {
+		// Note: turning on debug on macos throws errors but is marginally functional for debugging
+		// TODO (jmorganca): we should pre-create the window and then provide it here to
+		// webview so we can hide it from the start and make other modifications
+		wv := webview.New(debug)
+		// start the window hidden
+		hideWindow(wv.Window())
+		wv.SetTitle("Ollama")
+
+		// TODO (jmorganca): this isn't working yet since it needs to be set
+		// on the first page load, ideally in an interstitial page like `/token`
+		// that exists only to set the cookie and redirect to /
+		// wv.Init(fmt.Sprintf(`document.cookie = "token=%s; path=/"`, w.token))
+		init := `
+		// Disable reload
+		document.addEventListener('keydown', function(e) {
+			if ((e.ctrlKey || e.metaKey) && e.key === 'r') {
+				e.preventDefault();
+				return false;
+			}
+		});
+
+		// Prevent back/forward navigation
+		window.addEventListener('popstate', function(e) {
+			e.preventDefault();
+			history.pushState(null, '', window.location.pathname);
+			return false;
+		});
+
+		// Clear history on load
+		window.addEventListener('load', function() {
+			history.pushState(null, '', window.location.pathname);
+			window.history.replaceState(null, '', window.location.pathname);
+		});
+
+		// Set token cookie
+		document.cookie = "token=` + w.token + `; path=/";
+	`
+		// Windows-specific scrollbar styling
+		if runtime.GOOS == "windows" {
+			init += `
+				// Fix scrollbar styling for Edge WebView2 on Windows only
+				function updateScrollbarStyles() {
+					const isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+					const existingStyle = document.getElementById('scrollbar-style');
+					if (existingStyle) existingStyle.remove();
+					
+					const style = document.createElement('style');
+					style.id = 'scrollbar-style';
+					
+					if (isDark) {
+						style.textContent = ` + "`" + `
+							::-webkit-scrollbar { width: 6px !important; height: 6px !important; }
+							::-webkit-scrollbar-track { background: #1a1a1a !important; }
+							::-webkit-scrollbar-thumb { background: #404040 !important; border-radius: 6px !important; }
+							::-webkit-scrollbar-thumb:hover { background: #505050 !important; }
+							::-webkit-scrollbar-corner { background: #1a1a1a !important; }
+							::-webkit-scrollbar-button { 
+								background: transparent !important;
+								border: none !important;
+								width: 0px !important;
+								height: 0px !important;
+								margin: 0 !important;
+								padding: 0 !important;
+							}
+							::-webkit-scrollbar-button:vertical:start:decrement {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:vertical:end:increment {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:start:decrement {
+								background: transparent !important;
+								width: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:end:increment {
+								background: transparent !important;
+								width: 0px !important;
+							}
+						` + "`" + `;
+					} else {
+						style.textContent = ` + "`" + `
+							::-webkit-scrollbar { width: 6px !important; height: 6px !important; }
+							::-webkit-scrollbar-track { background: #f0f0f0 !important; }
+							::-webkit-scrollbar-thumb { background: #c0c0c0 !important; border-radius: 6px !important; }
+							::-webkit-scrollbar-thumb:hover { background: #a0a0a0 !important; }
+							::-webkit-scrollbar-corner { background: #f0f0f0 !important; }
+							::-webkit-scrollbar-button { 
+								background: transparent !important;
+								border: none !important;
+								width: 0px !important;
+								height: 0px !important;
+								margin: 0 !important;
+								padding: 0 !important;
+							}
+							::-webkit-scrollbar-button:vertical:start:decrement {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:vertical:end:increment {
+								background: transparent !important;
+								height: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:start:decrement {
+								background: transparent !important;
+								width: 0px !important;
+							}
+							::-webkit-scrollbar-button:horizontal:end:increment {
+								background: transparent !important;
+								width: 0px !important;
+							}
+						` + "`" + `;
+					}
+					document.head.appendChild(style);
+				}
+				
+				window.addEventListener('load', updateScrollbarStyles);
+				window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', updateScrollbarStyles);
+			`
+		}
+		// on windows make ctrl+n open new chat
+		// TODO (jmorganca): later we should use proper accelerators
+		// once we introduce a native menu for the window
+		// this is only used on windows since macOS uses the proper accelerators
+		if runtime.GOOS == "windows" {
+			init += `
+				document.addEventListener('keydown', function(e) {
+					if ((e.ctrlKey || e.metaKey) && e.key === 'n') {
+						e.preventDefault();
+						// Use the existing navigation method
+						history.pushState({}, '', '/c/new');
+						window.dispatchEvent(new PopStateEvent('popstate'));
+						return false;
+					}
+				});
+			`
+		}
+
+		init += `
+			window.OLLAMA_WEBSEARCH = true;
+		`
+
+		wv.Init(init)
+
+		// Add keyboard handler for zoom
+		wv.Init(`
+			window.addEventListener('keydown', function(e) {
+				// CMD/Ctrl + Plus/Equals (zoom in)
+				if ((e.metaKey || e.ctrlKey) && (e.key === '+' || e.key === '=')) {
+					e.preventDefault();
+					window.zoomIn && window.zoomIn();
+					return false;
+				}
+
+				// CMD/Ctrl + Minus (zoom out)
+				if ((e.metaKey || e.ctrlKey) && e.key === '-') {
+					e.preventDefault();
+					window.zoomOut && window.zoomOut();
+					return false;
+				}
+
+				// CMD/Ctrl + 0 (reset zoom)
+				if ((e.metaKey || e.ctrlKey) && e.key === '0') {
+					e.preventDefault();
+					window.zoomReset && window.zoomReset();
+					return false;
+				}
+			}, true);
+		`)
+
+		wv.Bind("zoomIn", func() {
+			current := wv.GetZoom()
+			wv.SetZoom(current + 0.1)
+		})
+
+		wv.Bind("zoomOut", func() {
+			current := wv.GetZoom()
+			wv.SetZoom(current - 0.1)
+		})
+
+		wv.Bind("zoomReset", func() {
+			wv.SetZoom(1.0)
+		})
+
+		wv.Bind("ready", func() {
+			showWindow(wv.Window())
+		})
+
+		wv.Bind("close", func() {
+			hideWindow(wv.Window())
+		})
+
+		// Webviews do not allow access to the file system by default, so we need to
+		// bind file system operations here
+		wv.Bind("selectModelsDirectory", func() {
+			go func() {
+				// Helper function to call the JavaScript callback with data or null
+				callCallback := func(data interface{}) {
+					dataJSON, _ := json.Marshal(data)
+					wv.Dispatch(func() {
+						wv.Eval(fmt.Sprintf("window.__selectModelsDirectoryCallback && window.__selectModelsDirectoryCallback(%s)", dataJSON))
+					})
+				}
+
+				directory, err := dialog.Directory().Title("Select Model Directory").ShowHidden(true).Browse()
+				if err != nil {
+					slog.Debug("Directory selection cancelled or failed", "error", err)
+					callCallback(nil)
+					return
+				}
+				slog.Debug("Directory selected", "path", directory)
+				callCallback(directory)
+			}()
+		})
+
+		// Bind selectFiles function for selecting multiple files at once
+		wv.Bind("selectFiles", func() {
+			go func() {
+				// Helper function to call the JavaScript callback with data or null
+				callCallback := func(data interface{}) {
+					dataJSON, _ := json.Marshal(data)
+					wv.Dispatch(func() {
+						wv.Eval(fmt.Sprintf("window.__selectFilesCallback && window.__selectFilesCallback(%s)", dataJSON))
+					})
+				}
+
+				// Define allowed extensions for native dialog filtering
+				textExts := []string{
+					"pdf", "docx", "txt", "md", "csv", "json", "xml", "html", "htm",
+					"js", "jsx", "ts", "tsx", "py", "java", "cpp", "c", "cc", "h", "cs", "php", "rb",
+					"go", "rs", "swift", "kt", "scala", "sh", "bat", "yaml", "yml", "toml", "ini",
+					"cfg", "conf", "log", "rtf",
+				}
+				imageExts := []string{"png", "jpg", "jpeg"}
+				allowedExts := append(textExts, imageExts...)
+
+				// Use native multiple file selection with extension filtering
+				filenames, err := dialog.File().
+					Filter("Supported Files", allowedExts...).
+					Title("Select Files").
+					LoadMultiple()
+				if err != nil {
+					slog.Debug("Multiple file selection cancelled or failed", "error", err)
+					callCallback(nil)
+					return
+				}
+
+				if len(filenames) == 0 {
+					callCallback(nil)
+					return
+				}
+
+				var files []map[string]string
+				maxFileSize := int64(10 * 1024 * 1024) // 10MB
+
+				for _, filename := range filenames {
+					// Check file extension (double-check after native dialog filtering)
+					ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(filename), "."))
+					validExt := false
+					for _, allowedExt := range allowedExts {
+						if ext == allowedExt {
+							validExt = true
+							break
+						}
+					}
+					if !validExt {
+						slog.Warn("file extension not allowed, skipping", "filename", filepath.Base(filename), "extension", ext)
+						continue
+					}
+
+					// Check file size before reading (pre-filter large files)
+					fileStat, err := os.Stat(filename)
+					if err != nil {
+						slog.Error("failed to get file info", "error", err, "filename", filename)
+						continue
+					}
+
+					if fileStat.Size() > maxFileSize {
+						slog.Warn("file too large, skipping", "filename", filepath.Base(filename), "size", fileStat.Size())
+						continue
+					}
+
+					fileBytes, err := os.ReadFile(filename)
+					if err != nil {
+						slog.Error("failed to read file", "error", err, "filename", filename)
+						continue
+					}
+
+					mimeType := http.DetectContentType(fileBytes)
+					dataURL := fmt.Sprintf("data:%s;base64,%s", mimeType, base64.StdEncoding.EncodeToString(fileBytes))
+
+					fileResult := map[string]string{
+						"filename": filepath.Base(filename),
+						"path":     filename,
+						"dataURL":  dataURL,
+					}
+
+					files = append(files, fileResult)
+				}
+
+				if len(files) == 0 {
+					callCallback(nil)
+				} else {
+					callCallback(files)
+				}
+			}()
+		})
+
+		wv.Bind("drag", func() {
+			wv.Dispatch(func() {
+				drag(wv.Window())
+			})
+		})
+
+		wv.Bind("doubleClick", func() {
+			wv.Dispatch(func() {
+				doubleClick(wv.Window())
+			})
+		})
+
+		// Add binding for working directory selection
+		wv.Bind("selectWorkingDirectory", func() {
+			go func() {
+				// Helper function to call the JavaScript callback with data or null
+				callCallback := func(data interface{}) {
+					dataJSON, _ := json.Marshal(data)
+					wv.Dispatch(func() {
+						wv.Eval(fmt.Sprintf("window.__selectWorkingDirectoryCallback && window.__selectWorkingDirectoryCallback(%s)", dataJSON))
+					})
+				}
+
+				directory, err := dialog.Directory().Title("Select Working Directory").ShowHidden(true).Browse()
+				if err != nil {
+					slog.Debug("Directory selection cancelled or failed", "error", err)
+					callCallback(nil)
+					return
+				}
+				slog.Debug("Directory selected", "path", directory)
+				callCallback(directory)
+			}()
+		})
+
+		wv.Bind("setContextMenuItems", func(items []map[string]interface{}) error {
+			menuMutex.Lock()
+			defer menuMutex.Unlock()
+
+			if len(menuItems) > 0 {
+				pinner.Unpin()
+			}
+
+			menuItems = nil
+			for _, item := range items {
+				menuItem := C.menuItem{
+					label:     C.CString(item["label"].(string)),
+					enabled:   0,
+					separator: 0,
+				}
+
+				if item["enabled"] != nil {
+					menuItem.enabled = 1
+				}
+
+				if item["separator"] != nil {
+					menuItem.separator = 1
+				}
+				menuItems = append(menuItems, menuItem)
+			}
+			return nil
+		})
+
+		// Debounce resize events
+		var resizeTimer *time.Timer
+		var resizeMutex sync.Mutex
+
+		wv.Bind("resize", func(width, height int) {
+			if w.Store != nil {
+				resizeMutex.Lock()
+				if resizeTimer != nil {
+					resizeTimer.Stop()
+				}
+				resizeTimer = time.AfterFunc(100*time.Millisecond, func() {
+					err := w.Store.SetWindowSize(width, height)
+					if err != nil {
+						slog.Error("failed to set window size", "error", err)
+					}
+				})
+				resizeMutex.Unlock()
+			}
+		})
+
+		// On Darwin, we can't have 2 threads both running global event loops
+		// but on Windows, the event loops are tied to the window, so we're
+		// able to run in both the tray and webview
+		if runtime.GOOS != "darwin" {
+			slog.Debug("starting webview event loop")
+			go func() {
+				wv.Run()
+				slog.Debug("webview event loop exited")
+			}()
+		}
+
+		if w.Store != nil {
+			width, height, err := w.Store.WindowSize()
+			if err != nil {
+				slog.Error("failed to get window size", "error", err)
+			}
+			if width > 0 && height > 0 {
+				wv.SetSize(width, height, webview.HintNone)
+			} else {
+				wv.SetSize(800, 600, webview.HintNone)
+			}
+		}
+		wv.SetSize(800, 600, webview.HintMin)
+
+		w.webview = wv
+		w.webview.Navigate(url)
+	} else {
+		w.webview.Eval(fmt.Sprintf(`
+			history.pushState({}, '', '%s');
+		`, path))
+		showWindow(w.webview.Window())
+	}
+
+	return w.webview.Window()
+}
+
+func (w *Webview) Terminate() {
+	w.mutex.Lock()
+	if w.webview == nil {
+		w.mutex.Unlock()
+		return
+	}
+
+	wv := w.webview
+	w.webview = nil
+	w.mutex.Unlock()
+	wv.Terminate()
+	wv.Destroy()
+}
+
+func (w *Webview) IsRunning() bool {
+	w.mutex.Lock()
+	defer w.mutex.Unlock()
+	return w.webview != nil
+}
+
+var (
+	menuItems []C.menuItem
+	menuMutex sync.RWMutex
+	pinner    runtime.Pinner
+)
+
+//export menu_get_item_count
+func menu_get_item_count() C.int {
+	menuMutex.RLock()
+	defer menuMutex.RUnlock()
+	return C.int(len(menuItems))
+}
+
+//export menu_get_items
+func menu_get_items() unsafe.Pointer {
+	menuMutex.RLock()
+	defer menuMutex.RUnlock()
+
+	if len(menuItems) == 0 {
+		return nil
+	}
+
+	// Return pointer to the slice data
+	pinner.Pin(&menuItems[0])
+	return unsafe.Pointer(&menuItems[0])
+}
+
+//export menu_handle_selection
+func menu_handle_selection(item *C.char) {
+	wv.webview.Eval(fmt.Sprintf("window.handleContextMenuResult('%s')", C.GoString(item)))
+}

app/cmd/squirrel/Info.plist

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>English</string>
+    <key>CFBundleExecutable</key>
+    <string>Squirrel</string>
+    <key>CFBundleIconFile</key>
+    <string/>
+    <key>CFBundleIdentifier</key>
+    <string>com.github.Squirrel</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>Squirrel</string>
+    <key>CFBundlePackageType</key>
+    <string>FMWK</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>CFBundleSignature</key>
+    <string>????</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <key>DTCompiler</key>
+    <string>com.apple.compilers.llvm.clang.1_0</string>
+    <key>DTSDKBuild</key>
+    <string>22E245</string>
+    <key>DTSDKName</key>
+    <string>macosx13.3</string>
+    <key>DTXcode</key>
+    <string>1431</string>
+    <key>DTXcodeBuild</key>
+    <string>14E300c</string>
+    <key>NSHumanReadableCopyright</key>
+    <string>Copyright © 2013 GitHub. All rights reserved.</string>
+    <key>NSPrincipalClass</key>
+    <string/>
+  </dict>
+</plist>
\ No newline at end of file