Admin Settings
Reference for the platform settings available to administrators of a self-managed JuliaHub installation. Settings are found under Admin → Settings, which is organized into tabs for instance, platform, registry, and compute configuration.
For operational procedures such as restarts and volume expansion, see Common Administrative Tasks.
On Helm and Replicated installations, several values are supplied by the license file or by Helm values and are read-only in the admin UI. These are called out below where they apply.
Server configuration
| Setting | Description |
|---|---|
| Session Idle Timeout | Minutes of inactivity before a user session expires. Minimum 60; defaults to 2880 (48 hours). |
| Long term token revocation cache TTL | Seconds that long-term token revocations are cached. 0 disables revocation checking. A nonzero value must be at least 60. |
| Administrators | Comma-separated list of administrator email addresses. At least one must resolve to a known user. |
| Enable Authenticated Package Server | Requires authentication to fetch packages from this installation's package server. |
The Administrators field exists mainly for bootstrapping an installation before identity providers are configured. Once users can log in, grant administrator access through Users & Groups instead — it is auditable and does not require editing a comma-separated list. See Administrator access for how this field is validated against your connectors.
Upstream package server
Controls where this installation synchronizes packages from.
The authentication token is carried in your license, so it is supplied by the installation rather than entered in the admin UI, where it is read-only.
- The token is injected from the license field
upstream_jh_auth_token. It can also be set directly as the Helm valuebootstrap.upstreamJh.authToken, or supplied from an existing secret viabootstrap.upstreamJh.existingSecretName. - The upstream host comes from
bootstrap.upstreamJh.host, which defaults tohttps://juliahub.com.
Package synchronization enables itself automatically when an upstream token is present and the installation is not air-gapped, so no manual setup step is required. Air-gapped installations ingest packages from bundles instead — see Offline Package Bundles.
Credentials
Credentials used by the platform to reach external systems, under Admin → Settings → Credentials.
Tokens
Access tokens for Git hosts and package servers. Each entry has:
- Name — identifier for the token
- Token — the secret value
- URL — the URL prefix the token applies to
Where the host supports it, JuliaHub displays the token's associated account, expiry date, and scopes, and warns when a token has expired.
The upstream package server token is shown here but is read-only; see Upstream package server.
SSH
Used for registries and packages accessed over SSH.
- SSH Host key — the host's public key. Obtain it with
ssh-keyscan <registry-host>. - SSH Private Key — uploaded as a file.
GitHub Apps
An alternative to personal access tokens for GitHub-backed registries, with finer-grained permissions and no user-tied expiry.
- App ID
- App Private Key — uploaded as a file
- URL Prefix — the GitHub host the app applies to
Registries
Registry configuration is now a top-level Registries page in the sidebar, not a tab inside Admin Settings.
A new installation is seeded with the General and JuliaHubRegistry registries, plus DyadRegistry where Dyad is enabled.
For day-to-day registry usage, see Registry Management. The settings below are the ones most relevant to installation and operations.
Registry details
| Setting | Description |
|---|---|
| Registry name | Display name. Fixed once the registry is created. |
| Registry owner | Users who administer the registry. |
| Cache resources | Which resource types to mirror locally: artifact, docs, metadata, and pkg. All enabled by default. |
| Display Applications | Surface applications from this registry in the UI. |
| Run Static Analysis | Run static code analysis over packages in this registry. |
| Docs HTML size threshold (bytes) | Skip caching generated documentation larger than this. |
| Synchronize from upstream | Whether this registry syncs from an upstream source. |
Provider types
How JuliaHub obtains the registry's contents:
| Type | Use |
|---|---|
gitserver | A Git-hosted registry. Supports GitHub, GitLab, Bitbucket, and bare Git over SSH. |
cacheserver | Another JuliaHub package server acting as an upstream cache. |
bundle | An offline package bundle. See Offline Package Bundles. |
genericserver | A generic package server. |
Git-backed providers additionally take a registry URL, the Git server type, and a credentials type — either a personal access token or a GitHub App.
Sync schedule
Controls when a synchronizing registry checks its upstream. Rather than a single interval, the schedule constrains sync to a window:
| Setting | Description |
|---|---|
| Days of Week | Days on which syncing may run. |
| Start Hour / End Hour | The daily window during which syncing may run. |
| Timezone | Timezone the hours are interpreted in. |
| Interval (minutes) | How often to sync within the window. Minimum and default 7. |
Restricting the window is useful when upstream bandwidth is shared or metered.
Cooldown period
Delays how quickly newly published upstream versions become available, expressed in days and hours. With a cooldown set, the registry serves the newest version that is older than the cooldown period rather than the newest version outright.
The served version never rewinds: once a version has been served, a later sync will not withdraw it. Cooldown requires a Git-backed registry download; bundle registries do not participate.
This is useful where you want a settling period before your users can resolve a brand-new release.
Registrator
Lets users register new packages into a registry, configured per registry under its Registrator tab.
| Setting | Description |
|---|---|
| Registration | Enables package registration for this registry. |
| Registry fork URL | The fork that registration pull requests are opened against. |
| Contact address used on registration requests. Required. | |
| Registration dependencies | Restricts dependencies: only packages from the registries listed here may be dependencies of packages in this registry. |
| Authorized registration | When enabled, only package authors may register a package. Enabled by default. |
| Verify SSL | Verify TLS certificates when contacting the Git host. Enabled by default. |
Triggering a sync after registration
Registration merges a pull request in the registry repository, but the platform does not learn about it until its next scheduled sync. To pick up new registrations immediately, have your CI call the sync endpoint after the merge:
POST https://<hostname>/app/sync/start
Authorization: Bearer <long-term-token>Generate the token under Token configuration. In GitHub Actions, store it as a repository secret and call the endpoint from a workflow triggered on pushes to the registry's default branch.
Token configuration
Generates long-term authentication tokens for programmatic access — CI jobs, JULIA_PKG_SERVER configuration, and the sync endpoint above.
Tokens can be downloaded as a token.toml for placing in a Julia depot.
Authentication
JuliaHub delegates authentication to an identity provider — LDAP or Active Directory, GitHub, GitLab, generic OpenID Connect, SAML, or an authenticating reverse proxy.
See Authentication for connector configuration, both through the admin console and at install time.
Authorization providers
Authorization providers let users grant JuliaHub delegated access to an external service on their behalf — for example to import a project from a private repository, or to write changes back to it. This is distinct from authentication, which controls who may log in.
Configure these under Admin → Settings → Authorization Providers.
| Field | Description |
|---|---|
| Name | Display name shown to users. |
| Authorization Mechanism | oauth or device_code. |
| Provider | The external service. |
| Authz URL | Base URL, for self-hosted instances. |
| Client ID | From the OAuth application you register with the provider. |
| Client Secret | Required for oauth; not used by device_code. |
| Scopes | Permissions requested from the provider. |
The following provider and mechanism combinations are supported:
| Provider | Mechanism |
|---|---|
github | oauth, device_code |
github-copilot | device_code |
gitlab | oauth |
bitbucket | oauth |
box | oauth |
dropbox | oauth |
Registering the OAuth application
When creating the OAuth application on the provider's side, set the callback URL to:
https://<hostname>/user/authorization/callbackJuliaHub derives this from the installation's configured protocol and hostname, so there is no redirect URI field in the admin UI.
Scopes for project import
The default read-only scopes are enough to browse and clone. Importing a project and pushing changes back requires write access:
| Provider | Scopes |
|---|---|
| GitHub | user:email, repo |
| GitLab | read_api, read_repository, write_repository |
| Bitbucket | repository, account, repository:write |
Without the write scope, imports succeed but pushing changes back fails.
Authorization provider settings are stored in the platform database and managed only through the admin UI. Earlier releases kept them in an authorizations.json configuration file; that file is no longer used except as a one-time migration source.