Silo

KO | EN

gitlite — search

#hacktoberfest #typescript #llm #golang #go #android #docker #macos #nodejs #awesome #awesome-list #mcp #ios #open-source

(★ 24)

Fast, native, open-source launcher for running Windows Steam games on Apple Silicon Macs.

Silo 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Silo

**A fast, native way to run Windows Steam games on Apple-silicon Macs.**

100% SwiftUI · Apple GPTK4/D3DMetal + DXMT graphics

[![Latest release](https://img.shields.io/github/v/release/mikaelhug/Silo)](https://github.com/mikaelhug/Silo/releases)
![Platform](https://img.shields.io/badge/platform-macOS%2015%2B%20%C2%B7%20Apple%20Silicon-blue)
![Swift](https://img.shields.io/badge/Swift%206-strict%20concurrency-orange)
[![License](https://img.shields.io/badge/license-LGPL--2.1+-blue)](https://raw.githubusercontent.com/mikaelhug/Silo/main/LICENSE)

[Discord](https://discord.gg/kNysBA9VU5) ·
[Website](https://mikaelhug.github.io/Silo/) ·
[Releases](https://github.com/mikaelhug/Silo/releases) ·
[Architecture](CLAUDE.md) ·
[Wine build](WINE-BUILD.md) ·
[Status](STATUS.md)

</div>

Silo stands up a real **Windows Steam client inside one shared Wine bottle**, and launches your games
**co-resident with it** on a Metal graphics backend it picks automatically — Apple's D3DMetal, or DXMT for
titles it can't run — so Steamworks and Steam DRM just work, no emulator, no fakery. It downloads its own
Wine, imports Apple's Game Porting Toolkit from your `.dmg`, and self-updates from GitHub Releases.

## Highlights

- **Real Steam, real DRM.** Steamworks IPC is prefix-scoped, so Silo runs each game in the same
  bottle as a logged-in Windows Steam client — auth tickets, ownership, and online features intact.
  Sign in once; Steam caches the login.
- **Automatic graphics backend.** All Steam games share **one** bottle, and Silo picks the Metal backend
  per game: **GPTK / D3DMetal** (Apple's D3D10/11/12 → Metal) by default, **DXMT** (a direct D3D10/11 →
  Metal layer) for 32-bit titles and as the fallback when GPTK can't drive a game — it remembers the switch
  for next time. Override to a specific backend per game whenever you want; GPTK and DXMT games co-reside.
- **Non-Steam games too.** Add any `.exe` (or run its installer); each manual game lives in its
  **own isolated Wine prefix** with the same **Automatic** graphics backend as Steam games (or an
  explicit override), plus per-game env flags and launch options.
- **Desktop shortcuts.** Right-click any game (Steam or non-Steam) → *Create Desktop Shortcut* for a
  double-clickable launcher that plays it through Silo — same backend, same bottle, Steam client and all —
  straight from the Desktop, Spotlight, or Launchpad.
- **Self-contained.** No Homebrew, no external dependencies: Wine comes from Silo's Releases
  (SHA-256 verified, fail-closed), GPTK from your Apple-downloaded `.dmg`, updates in-app.
- **Native and event-driven.** SwiftUI + Swift 6 strict concurrency; zero polling — game exits,
  Steam readiness, and log tailing are all kqueue-driven. Bottles are relocatable to an external
  drive (with a progress bar; exFAT refused).
- **Guardrails everywhere.** A silent GPTK→wined3d fallback is detected and surfaced instead of a
  black window; a corrupt `config.json` restores from its automatic backup; a bottles move or
  self-update is refused while a game or Steam client is live (and won't run over a process orphaned
  by a prior crash); launch logs open with the fully resolved environment.

## How it works

1. **Bottle** — provision **one** shared Wine prefix, install Windows Steam into it, and launch it with
   the CEF flags that make its UI actually paint under Wine. Every Steam game runs co-resident here.
2. **Discovery** — parse the bottle's `appmanifest_*.acf` (+ `libraryfolders.vdf`) into typed games.
3. **Backend choice** — per launch, Silo picks GPTK or DXMT (32-bit → DXMT, else GPTK) or honors your
   per-game override; a silent GPTK failure flips an Automatic game to DXMT for next time.
4. **Graphics overlay** — inject the chosen backend's modules into the Wine **runtime**'s own `lib/wine`
   tree (GPTK in place; DXMT on an APFS clone of the runtime), forced builtin at launch so nothing can
   shadow them. Idempotent, self-repairing.
5. **Launch** — resolve `(game, backend) → {prefix, runtime}` through one deterministic dispatch point
   (`BottleResolver`) and spawn the game co-resident with its Steam client, streaming to a per-game log.

Silo builds, tests, and browses a library with **zero runtimes installed** — everything
runtime-dependent degrades to a guided setup state, never a crash.

## First-run setup

The Library shows a guided setup until the pieces are in place:

1. **Import GPTK** — pick Apple's Game Porting Toolkit `.dmg`
   ([developer.apple.com/games](https://developer.apple.com/games/game-porting-toolkit/), free
   Apple ID required); Silo mounts it and extracts the D3DMetal layer.
2. **Set up** — one click chains the rest: download Wine (~250 MB) and the DXMT runtime from
   [Releases](https://github.com/mikaelhug/Silo/releases), install Windows Steam into the shared bottle
   (with its fonts and VC++ runtimes), then launch Steam and sign in once — Steam caches the login.

Then hit **Play**. Steam games default to **Automatic** graphics (GPTK/DXMT chosen per game, overridable in
per-game settings, which also cover the executable, performance flags — msync, Metal HUD, MetalFX,
raytracing, and D3DMetal's Metal 3 / Metal 4 renderer — and launch options). Settings (⌘,) manages
Wine/GPTK/DXMT runtime versions (import as many GPTKs as you like and switch the default in one click),
bottle tools
(Retina mode, winecfg/regedit), bottle location, and updates.

> **Gatekeeper:** the app is ad-hoc signed, so a downloaded build is quarantined until you
> right-click → Open (or `xattr -dr com.apple.quarantine Silo.app`).

## Build from source

Requires a Swift 6 toolchain — **Command Line Tools are sufficient, no Xcode needed**.

```sh
swift build              # compile
./Scripts/test.sh        # test suite — passes with no Wine/GPTK/Steam installed
./Scripts/build-app.sh   # assemble + ad-hoc sign dist/Silo.app
./Scripts/run.sh         # build the app and open it
./Scripts/dev.sh         # fast iteration: swift run silo
```

`Scripts/test.sh` wraps `swift test` with the Swift Testing search path Command Line Tools needs
(plain `swift test` fails with "no such module 'Testing'" without Xcode).

### Local Wine without GitHub

Pushing only powers the CI Wine build. To exercise the whole app locally:

```sh
./Scripts/build-wine.sh 26.2.0                # ~30–60 min, from CrossOver source
./Scripts/install-local-wine.sh .wine-build/install wine-cx-26.2.0
```

Then in the app: Settings → **Wine** → Set default, **GPTK** → import your `.dmg`, and the
Library onboarding's **Set up Steam bottle** runs everything else locally. Building DXMT
additionally needs full Xcode's Metal toolchain — see `Scripts/build-dxmt.sh`.

CI runs build + test on every push; tagging `v*` publishes an ad-hoc-signed `Silo.zip` (with its
`.sha256`) via `release.yml`. Every version number lives in one file, `versions.env`.

## Wine sourcing

Silo's Wine is compiled **from CrossOver's open (LGPL) sources in Silo's own CI** and published to
its Releases — no third-party prebuilt dependency, reproducible from `versions.env`. DXMT is built
from its upstream (`3Shain/dxmt`), pinned in `versions.env`, against that same Wine. Apple's D3DMetal
is imported from the user's GPTK `.dmg` (Apple-login-gated, so it is never auto-downloaded). See
[WINE-BUILD.md](WINE-BUILD.md).

## Sandboxing

Silo is **not** App-Sandboxed (see `Resources/silo.entitlements`): it executes `wine` outside its
bundle and reads/writes `~/Library/Application Support` and the bottles, which the sandbox forbids.
User-chosen paths go through the system file picker (powerbox) to avoid TCC denials.

## Legal

Silo is licensed under the [LGPL-2.1-or-later](LICENSE). Wine is redistributed under the same
license from CrossOver's published sources; GPTK stays your own Apple-licensed download. Silo never
bundles or auto-downloads a Steam-API emulator — games talk to the real Steam client you sign into,
in your own account. You are responsible for compliance with Steam's Subscriber Agreement and
applicable law.

Silo

Silo 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Silo

Silo 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README