Skip to content

Self-Host ODS on Apple Silicon: Setup and Remote Access

Install and verify ODS on an Apple Silicon Mac, understand its pre-release limits, then access your AI chat remotely with Localtonet over HTTP.

Summary in your language
In this article 9 sections
Self-Hosting Tutorials · ODS · Apple Silicon · Localtonet · 2026

Prepare your Mac, validate your AI workspace, and publish only a verified interface

ODS brings browser-based AI services, including Open WebUI and Portal, to a self-hosted deployment. This guide covers Apple Silicon Docker preparation, local service and model-request checks, operational diagnostics, and controlled remote access with Localtonet. ODS V3 is a pre-release with an important security notice, so installation provenance and access-control testing matter. The version-specific bootstrap, inference configuration, and recovery procedures remain outside this guide’s verified scope; use this as a preparation and validation guide, not a complete unattended ODS installer.

🔒 Test anonymous access before publishing 🌐 Verify ports 3000 and 3001 separately ⚡ Separate application health from tunnel connectivity
Apple Silicon Mac illustration showing the ODS workspace with Open WebUI and Portal.
Open WebUI and Portal are separate browser interfaces. Their availability does not by itself establish that an inference backend is working.

What ODS provides on an Apple Silicon Mac

ODS, the Osmantic Deployment System, describes its V3 offering as a private AI server stack for PCs, Macs, and Linux systems. For this workflow, the documented browser entry points are Open WebUI at http://localhost:3000 and Portal at http://localhost:3001/pixel. These are separate endpoints, and a successful test of one does not validate the other.

The ODS V3 pre-release notice explicitly distinguishes public testing from the official V3 launch. It says fleet qualification and UI/model-switching qualification are incomplete, with known acceptance failures in complex generated applications and event research. Passing CI or a basic chat test is therefore not a promise that every workflow will work on your Mac.

💬 Browser interface Open WebUI provides the documented chat entry point on port 3000. Validate account access and a completed model response separately.
🧭 Portal interface Portal uses port 3001 and the documented /pixel route. Publishing that port can expose more than this one page.
🐳 Container services Docker readiness is a prerequisite, not proof of model readiness or Apple GPU acceleration.
🌐 Optional remote access With Localtonet, a verified HTTP service can receive a public HTTPS address through an outbound client connection.

Understand the host/container boundary

Docker Desktop runs Linux containers through a Linux virtual machine on macOS. That environment is distinct from native macOS execution. An Apple Silicon-compatible container image does not automatically gain access to Apple GPU acceleration, and installing Docker does not establish Metal support for an inference engine.

Also distinguish three different loopback addresses: the Mac’s localhost, a container’s localhost, and another device’s localhost. A browser on the Mac can reach a published container port through the Mac’s loopback interface. A process inside a container cannot assume that its own loopback address points to a model server running natively on the Mac.

Docker Desktop commonly provides host.docker.internal for container-to-host connectivity. That is networking context, not an ODS configuration recommendation: the correct backend URL, port, bind address, and authentication must come from the installed ODS version’s supported configuration.

The current vLLM installation documentation lists Apple Silicon support through vLLM-Metal. This does not prove that ODS integrates that backend, selects it automatically, or supports a particular model through it. This guide cannot establish ODS’s actual macOS inference backend or its configuration prompts, so it does not prescribe vLLM, Ollama, MLX, or another runtime as an interchangeable substitute.

Prepare Docker and check the Mac

Use an Apple Silicon Mac that you are authorized to administer. On a managed device, confirm that container workloads and public tunneling comply with organizational policies. Model storage, container images, and application data all consume disk space; memory requirements depend on the model and inference implementation rather than just the browser interface.

Check architecture and available storage

uname -m
sw_vers
df -h "$HOME"

A native Apple Silicon terminal normally reports arm64. If it reports x86_64, check whether Terminal is running under Rosetta before selecting packages. Use About This Mac to confirm the hardware. Record the macOS version and free storage, but do not interpret either as a universal ODS compatibility guarantee.

Install and launch Docker Desktop

One practical way to prepare a Mac container engine is Docker Desktop for Mac. Obtain the Apple Silicon installer from Docker’s official download site, open the disk image, drag Docker into Applications, and launch Docker. Complete its setup and permission prompts, review its applicable license terms, and wait until the engine reports that it is running. This is Docker preparation, not a claim that every Docker Desktop release has been qualified by ODS.

Open a new terminal after setup and run:

docker version
docker info
docker compose version
docker run --rm hello-world

docker version should show both client and server information. Client output followed by a daemon connection error means the engine is not reachable. docker info should complete without that error, and docker compose version should print an installed Compose version. The final command downloads and runs a small test image and should print Docker’s success message.

The test image requires network access on its first run. A registry download failure can indicate DNS, proxy, connectivity, or registry access trouble rather than a broken ODS installation. Resolve it before continuing. If Docker points to an unexpected engine, inspect docker context show and docker context ls before changing anything.

Check whether the intended ports are already occupied

lsof -nP -iTCP:3000 -sTCP:LISTEN
lsof -nP -iTCP:3001 -sTCP:LISTEN
docker ps --format 'table {{.ID}}\t{{.Names}}\t{{.Ports}}'

Before ODS installation, no output from an lsof check normally means no visible listener was found on that port. If a listener exists, identify its owner. Docker Desktop may appear as the listening process for published container ports, so compare the container port mappings too. Do not kill an unfamiliar process or change ODS ports without understanding the dependency.

Installation provenance and the remaining setup boundary

This is not a verified bootstrap recipe

The complete current ODS README, installer body, and upstream macOS instructions have not been reviewed for this revision. Consequently, this guide cannot provide a verified bootstrap command, exact prompts, backend configuration, or existing-installation code-update sequence. A changing installer can be documented safely after version-qualified review; mutability alone is not a reason to omit it.

The documented high-level installation path requires Docker to be installed and running, followed by the project’s hosted Linux/macOS shell bootstrap. The official Osmantic/ODS repository is the authority for that procedure. A macOS quickstart from a differently owned fork is not sufficient to establish the current upstream workflow.

Before executing the upstream bootstrap, establish which source revision it uses, whether it fetches additional moving branches or container tags, where it stores persistent data, and what privileges it requests. Saving only the first shell script does not pin dependencies that script downloads later. Record the installer revision and resolved image versions if you need a reproducible evaluation.

Do not substitute git pull, a guessed docker compose up command, or a guessed ods subcommand for the documented installation or migration process. Those commands can miss generated configuration, database migrations, native host services, and dependency changes.

Do not pin the affected V3 tag

The V3 release notice identifies the fixed v3.0.0 tag, pinned to bec0c42e7c9885a5aecd419a166a6a81e0d37236, as affected by critical advisory GHSA-vqpg-pvjj-4cmq. Its security notice dated October 4, 2026 says the fix is on main, which the README installers use. The fixed tag and main are not equivalent installation sources.

Do not select the vulnerable tag merely to make the installation reproducible. A reproducible evaluation needs a reviewed, patched revision and its dependencies. The GitHub “Latest” label and unchanged numeric product version do not establish that an installed system contains the fix.

For an existing installation, the release notice explicitly says ods update alone does not apply code fixes. The verified remediation direction is to follow the project’s “Updating an existing installation” procedure linked from that notice. This guide does not have the complete procedure and cannot safely replace it with a command sequence. Keep an affected or uncertain installation off the public internet until remediation is confirmed.

Verify local services and a complete model request

A browser on the Mac connects separately to the Open WebUI and Portal local endpoints.
These are browser connectivity checks, not a diagram of the inference backend or its GPU access.

Continue here only after completing the upstream installation. Keep public tunnels stopped. First inspect the containers and published ports, then check the browser routes:

docker ps -a --format 'table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}'
curl --max-time 10 -sS -o /dev/null -w 'Open WebUI: %{http_code}\n' http://localhost:3000/
curl --max-time 10 -sS -o /dev/null -w 'Portal: %{http_code}\n' http://localhost:3001/pixel

A 200 response or an expected sign-in redirect shows that an HTTP endpoint responded. A 401 or 403 can be appropriate for protected content. A connection failure or status 000 means no usable HTTP response was received. A 500-class response means the server answered but failed to handle the request correctly. None of these status checks alone validates inference or authorization.

Initialize and test the browser interface

Open http://localhost:3000 and complete the installed version’s account setup locally. Use a unique administrative password and keep ordinary usage separate from administration where the application supports it. Then open http://localhost:3001/pixel independently. Record redirects and any setup screens rather than assuming both services share one authorization policy.

The exact authentication-setting names and backend-selection prompts are not established here. If you cannot identify and configure supported authentication in the installed version, stop at local evaluation rather than publishing the service.

Run a model acceptance test

  1. Confirm which inference backend the installation actually configured and whether it runs on the Mac, inside a container, or at an external provider.
  2. Verify that a model is available in the interface. A visible model name is not proof that its weights loaded or that credentials are valid.
  3. Start a fresh conversation with no private documents attached. Submit a simple prompt such as Reply with exactly: ODS local test complete.
  4. Wait for generation to finish. Record the model identifier, backend, time, and any error. Minor wording differences are not a connectivity failure; an error or stalled request is.
  5. Submit a second message in the same conversation to check continued operation. Test your actual intended workload separately.

A successful result is a completed response from the intended backend, not just an animated typing indicator. If local-only processing matters, verify the configured backend destination: a browser hosted on your Mac can still send inference requests to an external service. This is a test procedure, not a claim that a particular ODS/macOS model combination was tested for this article.

Inspect, maintain, and recover the deployment

Keep a short deployment record containing the source revision, installation date, Docker version, container images, model/backend selection, persistent storage locations, and verified workflows. Do not include passwords or tokens in a shared record.

Status and logs without guessing ODS service names

Discover the real container names with docker ps -a. Set the following variable to one identified ODS container before running these generic Docker diagnostics:

CONTAINER='replace-with-an-actual-ODS-container-name'
docker inspect --format '{{json .State}}' "$CONTAINER"
docker logs --tail 100 --timestamps "$CONTAINER"
docker inspect --format '{{json .Mounts}}' "$CONTAINER"
docker inspect --format '{{json .HostConfig.RestartPolicy}}' "$CONTAINER"

State output helps distinguish running, exited, restarting, and resource-related failures. Logs may reveal missing configuration, connection failures, or model-loading errors. Mount information identifies bind mounts and volumes; the restart policy describes container restart behavior, not native host-service recovery. Some applications write logs elsewhere, so empty container logs do not prove health.

Inspect output and logs can contain sensitive paths, prompts, or credentials. Redact them before sharing. Avoid dumping all environment variables into a support ticket.

Stop/start and reboot recovery

The supported ODS-wide stop/start procedure is not established here. For a deliberately selected standalone container, Docker provides docker stop "$CONTAINER" and docker start "$CONTAINER". These are container-level operations, not substitutes for an ODS lifecycle command: they do not coordinate dependent services or restart a native model process.

Stop the Localtonet tunnel before maintenance. After a reboot, launch Docker Desktop if it is not already running, confirm the engine responds, inspect container state, and check any native inference service separately. Repeat the local page and model tests before restoring remote access. An existing container restart policy does not guarantee that Docker Desktop starts before login or that all ODS dependencies recover in the correct order.

Sleep also interrupts availability. Keep the Mac powered and awake for an intentional remote-access session, in accordance with its power-management policies. Neither a configured tunnel nor an installed container makes a sleeping laptop an always-on server.

Backup and restore planning

A source checkout and a list of images are not a data backup. Inventory named volumes, bind-mounted directories, configuration, authentication state, uploaded files, conversations, and any native backend data. Use the mount inspection above as a starting point, not a complete application data map.

For databases, use the database’s supported backup method or a documented, consistent shutdown procedure. Copying live database files can produce an unusable backup. Protect secrets separately and encrypt backup storage where appropriate. Avoid docker compose down -v or volume-pruning commands during routine troubleshooting because they can remove persistent data.

No verified ODS backup command, volume inventory, or restore order is available here. Until those are established, do not entrust the deployment with irreplaceable data. A recovery test should restore into an isolated environment, use compatible application versions, and verify accounts, conversations, files, configuration, and model requests before reopening remote access.

Publish one verified HTTP interface with Localtonet

Remote browser connects through a Localtonet public endpoint to Open WebUI on the Mac.
The tunnel carries browser traffic to the selected local HTTP port. It does not configure inference or add application authorization.

Our client establishes an outbound connection to a Localtonet relay. This provides a public URL without inbound router port forwarding, firewall changes, VPN setup, or a public IP address. Use it only where your device and network policies permit. Standard HTTP tunneling is not a private mesh VPN.

Run our client directly on the ODS Mac for the simplest target configuration. Use 127.0.0.1:3000 for Open WebUI or 127.0.0.1:3001 for Portal. If the client runs on another device, use the Mac’s reachable LAN address instead, and confirm that the service accepts that connection.

The configuration sequence below includes Process Type selection. Consult the HTTP tunnel documentation for current interface details; available options can vary by plan and client version.

1

Install and run our client

Install the Localtonet application for your operating system and run it on the device that can reach ODS. Keep its device-specific authentication token private.

2

Open the HTTP tunnel configuration

Use the HTTP tunnel page in the dashboard for the browser interface, rather than a raw TCP, proxy, or File Server configuration.

3

Select Process Type

Choose Random Sub Domain, Custom Sub Domain, or Custom Domain as available. Each serves the selected content at a public HTTPS address. For custom domains, follow the current documented DNS requirements rather than guessing records.

4

Select AuthToken and server

Select the token for the connected client and a currently available relay server. Obtain server values from the dashboard, not a hardcoded example.

5

Enter the local IP address and port

For a client on the ODS Mac, enter 127.0.0.1 and port 3000 for Open WebUI, or 3001 for Portal. A URL path such as /pixel is not part of the local IP or port.

6

Start the tunnel

Press Start after configuration and use the assigned public address. Creating a configuration does not start it. Availability requires the selected client to remain connected and the tunnel to remain running.

Verify externally after configuration

From a separate connection, such as a phone using cellular data, open the public HTTPS address. For Portal, append /pixel. First test signed out, then authenticate with a non-administrative account where supported and repeat the model acceptance test. A successful page load alone is insufficient.

Check a full response, follow-up message, and any streaming behavior you need. If generation works locally but fails remotely, compare browser network errors and application logs at the same timestamp. Do not disable authentication or origin protections merely to make the remote test pass.

Test authorization before allowing remote use

A tunnel changes reachability, not permissions. Complete first-run setup locally and establish the installed application’s supported authentication policy before pressing Start. If anonymous users can create privileged accounts, read conversations, change configuration, or run expensive workloads, do not publish the interface.

Hermes owner cards are not Portal-wide authorization

The V3 release notice states that Hermes opens without an owner card on default installations, that administrators can opt into an owner-card gate, and that internal API and WebSocket authentication remain in place. Those statements do not establish that every Portal page, generated application, file route, or browser action is protected.

The exact owner-card configuration mechanism is not verified here. Do not invent an environment variable or assume enabling that gate secures all of port 3001. Similarly, appending /pixel to a shared URL does not restrict a tunnel to that path; other routes on the same service may remain reachable.

Use a signed-out acceptance checklist

  • Open a new private browser session without signing in and load each interface you plan to expose.
  • Attempt to open a known conversation, settings page, and private file from your own test account. Expect denial or a sign-in requirement, not private data.
  • Try a harmless model request without authentication if the interface permits it. Confirm the result matches your intended policy.
  • Inspect failed requests in browser developer tools. A public HTML shell returning 200 can still be safe if protected data and actions are denied.
  • Sign in as the least-privileged intended user and verify that normal chat works while administrative actions remain unavailable.
  • Repeat the checks on the public origin. Local and remote sessions can behave differently because of cookie, redirect, and origin settings.

For an API endpoint actually observed in your own installation, repeat its request without its authentication cookie or authorization header. Do this only with harmless operations and test data. Do not guess an API path or invent a bearer-token scheme. Keep browser “Copy as cURL” output private because it can contain session credentials.

A public URL is not an access-control system

Do not rely on an obscure address to protect AI conversations, provider credentials, or administrative functions. If you cannot verify authentication for the selected interface, keep it local. Stop remote access during updates and recovery.

Diagnose failures at the correct layer

SymptomConcrete checkInterpretation and next action
Docker commands cannot connectdocker info and docker context showStart the intended engine and verify the context before investigating ODS.
Local page refuses connectionslsof on the port, then docker ps -aLook for a missing listener, stopped container, or incorrect port mapping.
Port already allocatedCompare listeners with container port mappings.Identify the conflicting application; do not terminate unrelated services blindly.
Portal fails while chat worksRequest http://localhost:3001/pixel.Check Portal independently, including its logs and exact route.
Model request fails locallyCorrelate browser errors with backend logs.Investigate model availability, backend address, credentials, memory, and runtime compatibility.
Public endpoint is offlineCheck client connection, tunnel Start state, and local target.The configuration may exist while the client or tunnel is stopped.
Failure follows sleep or rebootRepeat engine, container, backend, and localhost checks.Restore each dependency before retesting the tunnel.

The interface loads but generation fails

Use the browser’s network panel to identify the failed request and status. An authorization error suggests a different problem from connection refusal or an out-of-memory event. Check whether the model is installed, whether the backend process is listening, and whether the configured URL is reachable from the process that makes the request.

Use docker stats --no-stream for container resource usage and Activity Monitor for native host processes and overall memory pressure. Container statistics do not measure a native inference engine. A model that exceeds available resources can fail even while the web interface remains responsive.

Local access succeeds but authenticated remote requests fail

Confirm that the public origin reaches the intended port and route. Compare a signed-out request with a signed-in one. Redirect loops, cookies not being sent, and origin-validation failures require application configuration review, not a different model download. Preserve authentication protections while resolving the supported public-origin settings.

If the page loads but streaming stalls, capture the failed browser request, timestamp, and corresponding service logs. Separate ordinary page delivery from the long-running request. Retest with the same model locally before attributing the failure to the tunnel.

Behavior changes after an update

Stop public exposure and compare the recorded source revision, images, configuration, and backend settings. Do not use the displayed V3 version alone as a security check. Repeat account, signed-out, model, and recovery tests before returning the service to use. If recovery depends on an untested backup, keep the installation in evaluation rather than treating it as production infrastructure.

Frequently asked questions

Is ODS V3 production-ready?

The release notice describes V3 as a pre-release in public testing, with incomplete fleet and model-switching qualification. Validate your exact installation and workload rather than assuming production readiness.

Can I complete a fresh ODS installation using only this guide?

No. This guide covers preparation, validation, diagnostics, and remote access. A reviewed, version-qualified bootstrap, backend configuration, and ODS recovery procedure are still needed from upstream. It does not present guessed commands as a complete installation path.

Does Docker automatically accelerate ODS with the Apple GPU?

No. Container compatibility and GPU acceleration are separate questions. The actual inference backend, its execution environment, and its supported acceleration path must be verified. Upstream vLLM-Metal support does not establish ODS integration.

Which local URL and port should I use?

Open WebUI uses http://localhost:3000. Portal uses http://localhost:3001/pixel. For remote chat, begin with port 3000 and expose Portal only if it is necessary and separately secured.

Does Localtonet require router port forwarding?

No. Our client connects outward to a relay, providing a public endpoint without inbound router port forwarding, firewall changes, VPN setup, or a public IP address. Application authentication is still required.

Can the client run on another device, and is a created tunnel already online?

The client can run on another device if it can reach the ODS service. Use the Mac’s reachable address rather than that device’s loopback address. Creating a tunnel is not enough: press Start, and keep the selected client connected and the tunnel running.

Does ods update apply the V3 security fix?

The V3 notice explicitly says ods update alone does not apply code fixes. Follow its linked existing-installation update procedure, verify the installed revision and behavior, and do not deploy the affected fixed tag for reproducibility.

Bring a verified ODS interface online with Localtonet

Once your patched installation completes local model requests and passes authentication checks, publish only the HTTP interface you need. Keep your device token private, test the public origin independently, and stop the tunnel during maintenance.

Get Started Free →

Corrections & updates

Substantive changes approved by the Localtonet editorial team are listed transparently below.

Reviewed and updated for accuracy and completeness.

Localtonet is a secure multi-protocol tunneling and proxy platform designed to expose localhost, devices, private services, and AI agents to the public internet supporting HTTP/HTTPS tunnels, TCP/UDP forwarding, mobile proxy infrastructure, file server publishing, latency-optimized game connectivity, and developer-ready AI agent endpoint exposure from a single unified control plane.

Support