Skip to content

About

Native runtime system, graphics/effects layer and tinker tool for Mac: play Windows, PS5, Switch, Android, iOS and 32-bit games on macOS/Apple Silicon without Wine or an emulator (RPG Maker, Ren'Py, GameMaker, Godot, Unity, visual novels…), with ReShade, Lossless Scaling (LSFG) frame generation, DLSS, FSR, XeSS, MetalFX upscaling and GPU shaders.

procrastinine.github.io/maclauncher/

Topics

32-bitandroid-gamesapple-silicondlssframe-generationfsrgamemakerlossless-scalinglsfgmac-gamingmacosmetalfxnintendo-switchps5renpyreshaderpg-makerupscalingvisual-novelxess

Resources

Readme
MIT license
Activity

Stars

3 stars

Watchers

0 watching

Forks

0 forks
Report repository
BranchesTags

Repository files navigation

MacLauncher logo

MacLauncher

MacLauncher is a native runtime system, graphics/effects layer, and tinker tool for playing games on macOS. tl;dr:

  • Native runtime system: MacLauncher collects and automatically handles many different native macOS runtimes for a large variety of games. You can drag in some exe, it will automatically detect what engine and runtime versions should be best supported for it to run natively on macOS, and the runtime installation and management will be automatically handled for you. See the screenshot below for a small sample of what it can run natively (without WINE/CrossOver).
  • Graphics/effects layer: MacLauncher includes a very powerful graphics subsystem, with neural upscaling, frame generation, DLSS 5, and pretty much any custom shader you can import yourself, in any arbitrary combination (including ports of Lossless Scaling and ReShade to macOS). All of this runs natively on Metal and across all runtimes.
  • Tinker tool: MacLauncher has a whole host of tools for power users. There is version management for everything, custom depot downloads for Steam for e.g. downloading Windows versions of games without using CrossOver, a large selection of extractors/decompilers and cheat tools, etc.

The website has an interactive demo of the launcher and longer explanations of everything here.

Import a game, adjust runtime and graphics settings, then play

Shown: Android version of Shattered Pixel Dungeon with CRT Royale shaders.

Running MacLauncher

The easiest way to run is through MacLauncher.app in the Releases. It is ad-hoc signed and you will need to allow it through Gatekeeper because I don't want to pay Apple $100 per year for a developer ID.

There are two separate apps, MacLauncher.app.zip for Apple Silicon and MacLauncher-Intel.app.zip for Intel Macs, and both share the same library, settings and runtimes. Either needs macOS 13 or later. Some runtimes and graphics features need Apple Silicon or a newer macOS (e.g. Android and Switch need Apple Silicon, and PS5 needs macOS 26), and MacLauncher just turns off what your Mac can't run; see Macs and macOS versions for what works where.

How to do it: Open Anyway in System Settings → Privacy & Security

You can also run from source, and everything should be the same.

MacLauncher as a native runtime system

Idea

A surprising number of games have runtimes that are available on macOS (and Linux) even though the games themselves are packaged for Windows and don't work out of the box. These games don't require WINE or emulation, and running natively can gain you higher performance and (sometimes) better compatibility. One of the purposes of MacLauncher is to configure these native runtimes automatically, with version management, so you can just drag in a game directory or exe and start playing with the maximally compatible version (or choose one yourself).

This launcher started by taking the patches in https://github.com/bakustarver/rpgmakermlinux-cicpoffs to macOS and wrapping it all in a UI, although I have added many more features since then. It has now gotten to the point where a nontrivial proportion of indie games meant for Windows can just be dragged in and played without requiring WINE (at least with the sampling bias of "indie games I personally thought of"), and similarly for iOS and Android. Still, compatibility is at the level of "try it" for many things, mainly depending on the specific runtime (for example, Ren'Py and HTML5 RPGMaker have basically perfect compatibility, but Unity is much more uneven).

Why use a native runtime?

There are quite a few benefits to using native macOS runtimes for games, even when CrossOver compatibility is quite good and some developers distribute native mac builds.

  • Games are generally more performant and efficient running under native runtimes compared to CrossOver/WINE.
  • Compatibility is often better on native runtimes as well, although sometimes it goes the other way.
  • Native runtimes have better OS integration (window management, mouse behavior, etc). I have had so much more "erratic" behavior (mouse movements not feeling right, windowed vs fullscreen mode issues or blocks, kind of corrupted sound, etc) on CrossOver, so in practice, if a game can launch in MacLauncher, I prefer to use it.
  • Some .app deployments for indie games (e.g. itch.io) are broken because the developer just clicked "build for mac" and never test it, and the .app then runs into signing or packaging problems. This is perfectly avoidable and can be solved by just pointing a properly working runtime at its data.

This is similar in spirit to the many decomp-recomp projects that can already be played via WINE or emulator but where people still benefit from a native runtime. Most decomp-recomp projects are ports of individual older console games, though, while MacLauncher covers qualitatively different games: indie games built on shared engines, mobile games, visual novels, and so on. MacLauncher doesn't provide these individual ports itself, as there are just so many of them (and it instead focuses on shared runtimes), but it is fully compatible with them: download a port's macOS build through e.g. Quiver Launcher and drag it into MacLauncher, where it runs like any other native Mac game. I am also considering adding some sort of "game store" for these individual games if creating scripts for a large number of them ever becomes personally tractable.

Game support

MacLauncher supports many game types. Please see the module inventory for details. A summary:

  • macOS apps/scripts/binaries: these are .app, .sh, Mach-O binaries, etc, that are already made for macOS. Why would you want to run these in MacLauncher? Well, outside of using MacLauncher as a game manager, there are several reasons:
    • MacLauncher provides an easy way to remove Apple quarantine (e.g. apps showing as "damaged") and allow execution for scripts and binaries.
    • You might want to run things through this interface due to the graphics layer, e.g. you want to use DLSS or a shader on a macOS native game.
    • Excitingly, you can run 32-bit macOS binaries that were unsupported all the way back in Catalina! This is provided through the mac32 runtime, and although compatibility is not perfect yet, it can run e.g. Portal 2.
  • Windows games: there are many!
    • RPGMaker: 2000/2003 through EasyRPG Player, MV/MZ through Electron or NW.js, XP/VX/VX Ace through MKXP-Z.
    • HTML games: similarly to RPGMaker MV/MZ, most games based on web technologies will "just work", including Construct, TyranoBuilder and GameMaker HTML5.
    • Ren'Py
    • Godot (note: version matching is very important here! e.g. Godot 4.5 and 4.6 are usually not cross-compatible! Luckily MacLauncher auto-detects the version of Godot a game was made with)
    • LÖVE
    • GameMaker: you can use the official GameMaker runtime, or alternatively, Butterscotch for GameMaker Studio and OpenGMK for GameMaker classic (custom macOS port).
    • Unity: Mono games can usually run through the macOS Unity player and are supported in MacLauncher (similarly to Godot, version management is important, and MacLauncher does it for you). Il2Cpp translates everything into system calls so you need WINE for that. Basically, some Unity games (the ones having little Windows-specific code) work, others do not.
    • XNA/FNA: with FNA, FNA3D, FAudio and .NET.
    • WOLF RPG: with Browser Woditor.
    • Flash (.swf): via Adobe Flash Projector or Ruffle
    • Java: with Temurin version management, Vineflower decompilation, and steamworks4j.
    • Infinity Engine: GemRB.
    • Adventure games: with ScummVM.
    • MUGEN: Ikemen GO.
    • Haxe: HashLink.
    • DOS games: through DOSBox Staging, including DOS .exe, .com. This one is emulation which is "fine" because the resource needs are so low.
    • Visual novels: there are a lot. Surprisingly many VN engines get cross-platform runtimes. Here is what MacLauncher currently supports:
    • Other Windows executables: you can provide a local CrossOver application to run any Windows executable, and you can manage multiple versions of it. Or alternatively if you don't have CrossOver, MacLauncher can also manage the free Sikarugir for you, which is largely the same thing (WINE with graphics translation layers). There are some convenient options built in, such as easy options to set the locale and a workaround for BepinEx to work, as well as the standard graphics options and WINE flags. See the CrossOver guide for details.
  • Mobile games: we have runtimes that run things natively (like WINE), not through emulation!
    • iOS / iPadOS: through PlayCover, or more specifically PlayTools
    • Android, or ARM64 VR/XR: MacLauncher offers the Mac.apk and AIM runtimes, both of which can play .apk on mac (Mac.apk through what is basically Java, AIM through Android's own ART runtime). In addition, MacLauncher itself offers the MacLauncher-Android runtime which is specifically for games and (in my testing) more compatible with complex commercial games (think Roblox or Hungry Shark Evolution or the like), plus compatible with VR/XR (e.g. Beat Saber) due to being built on Klepton.
  • Game consoles: again, native, not emulated
    • PlayStation 5: through AnyPS5, which converts PS5 executables into Intel macOS binaries that run natively on Intel Macs and through Rosetta on Apple Silicon. MacLauncher handles conversion, runtime versions, the Vulkan driver, and keyboard/mouse/controller settings. This requires unpacked, decrypted game files and macOS 26+. There is also an optional Prosper backend. See the PS5 and Prosper guides for details.
    • Nintendo Switch: through nxnative, running ARM64 game code on Apple Silicon with Metal graphics. You can import .nsp, .nsz, .xci or .xcz games, and MacLauncher handles extraction, preparation, runtime versions and shader compilation. Encrypted games need your own prod.keys. See the Switch guide for details.
  • Videos: it is kind of funny but you can play videos through MacLauncher via mpv, which is useful due to the whole graphics layer meaning we can upscale and apply effects on videos as well as games. MacLauncher supports mpv plugins (by default, uosc and thumbfast) but you can add any yourself, and also supports playlists in folders, saved watch positions, and subtitles. You can also preview and export videos with effects applied; see the video guide.

Missing runtimes can be downloaded when you press Play, after asking for permission, and then the game preparation and launch continue automatically. Installed versions stay available offline, and you can keep different versions for different games.

If a game lives on an external drive that is unplugged, or you move or rename its folder, the game just shows as Unavailable and nothing it has stored is touched. Plug the drive back in and it comes back, or use Locate… to point it at the new location while keeping its saves, settings and effects.

Unique features

Most of the above runtimes are existing tools with MacLauncher managing them. However, there is also a significant amount of functionality and compatibility that you can't find anywhere else. Here are some highlights:

MacLauncher as a graphics and effects layer

Maybe the most useful thing about MacLauncher is that it provides a very powerful graphics postprocessing system where you can control exactly what graphics/effects you apply, with very broad support. All of these effects run on native Metal, not WINE, and work across any runtime you want to use inside MacLauncher. i.e., you could literally drag Microsoft Word into MacLauncher and apply GFX to it lmao. Here is what's included:

Scene-based temporal upscaling and frame generation need matching depth, motion and other inputs from the game renderer. The available choices also depend on the macOS version and GPU; see the graphics providers for the specific requirements. LS1/LSFG use your own purchased Lossless Scaling copy, which can be imported or downloaded through Steam from the Runtimes panel.

The UI has Simple and Advanced views of the same pipeline. Simple gives you dropdowns for image filters, resizing and temporal effects; Advanced lets you add and reorder individual steps. Switching between them keeps your settings. You can save a whole chain as a preset and apply it to other games, or turn Graphics off while keeping everything for later. Shader collections, model downloads/imports and default choices are managed in Runtimes → Graphics.

Processing sizes are also configurable at each step: a fraction of the previous image, a fraction of the window/fullscreen size, or a fixed width/height (e.g. 540p). The window can stay the same size while the effects run at a different resolution. Game render resolution is a separate control, so downsampling an already rendered image reduces the work for the effects that follow it, without making the game itself render faster. A Downsample step can also use adaptive quality, which adjusts its working size within your chosen bounds to stay inside a GPU time budget.

Furthermore, the powerful part of MacLauncher is that it not only is able to apply these effects, but is able to apply them in any order, and any combination. Take the following use case, for example:

  • We want to use DLSS 5 to see what games can look like when we try to make them "realistic".
  • However, DLSS 5 is slow as hell, especially on my wimpy MacBook from the M2 generation with no neural accelerators. It is completely unplayable if we just try to apply it.
  • Thus, we can apply a pipeline: first, render or downsample the game at ~720p, run DLSS 5 on 720p, then upsample (e.g. using MetalFX) to your actual screen resolution (e.g. 4k), which can all be handled through stacking effects in MacLauncher.
  • It turns out that my wimpy MacBook struggles even like this, hitting an abysmal 15fps or so even DLSS-ing at 720p, so "real time" but not pleasant. Therefore, you can then apply Lossless Scaling frame generation, say 4x, yielding 60fps. I tried it, and yes it is "smooth". Now, would I want to play competitive games with this? Hell no, the input latency is crap, frame generation isn't perfect, and upscaling ultimately makes the image lose detail (although it is often pretty good). But is it fun to mess with DLSS and be able to play the game? In my opinion, absolutely.
  • If you additionally want to change the colors or make it look like it came out of a CRT, you can play with whatever shaders you want on top of that.
  • And notice in this process what you can do:
    • Change any parameters you want (e.g. DLSS strength, how much to upscale, shader parameters) in any step of the process
    • Change the pipeline in any way while looking at the game window, live, for the change in effects, without having to go out of the game or restart
    • And this applies for all games! Whatever macOS .app, something running on CrossOver, a browser game, Android/iOS, visual novels, whatever you want!

Unique features

A lot of these graphics features are custom ports to macOS that are again found nowhere else and are unique to MacLauncher. For example:

  • The graphics layer itself: custom macOS ports of Lossless Scaling and ReShade, with neural models, shaders, upscaling and frame generation all in one pipeline. The interesting part is being able to combine all of these, in whatever order you want, across the different runtimes, and change them live while looking at the game.
  • Native Metal ports of AMD FSR 1/2/3/4, Arm ASR and Snapdragon GSR 2, using the same graphics layer. These include temporal upscaling and FSR 3 frame generation, with the game's actual depth/motion inputs.
  • MLX neural processing for Intel games too: the game can be running under Rosetta or CrossOver while an Apple Silicon helper runs the neural models on the GPU.

Some other graphics implementations/adaptations in MacLauncher:

  • RIFE 4.6 frame interpolation, adapted to run through MLX/Metal in the same pipeline as everything else.
  • Real-ESRGAN and NAFNet upscaling/restoration, building on existing Real-ESRGAN MLX and NAFNet MLX ports and adapted into the shared model runtime and live graphics pipeline.
  • A Real-CUGAN implementation on MLX/Metal, using its original 2x/3x/4x models.
  • Depth Anything V2 Small on MLX/Metal, used for image-based depth fog.
  • Native Metal ports of CMAA2 antialiasing, XeGTAO ambient occlusion, and AMD CACAO, FidelityFX depth of field, Lens and Blur.
  • GPU adaptations of anisotropic Kuwahara (the painterly effect) and Halide's local Laplacian filter (detail/contrast).
  • Godot's screen-space reflections, SSRT3 indirect lighting, and FXShaders depth fog/outlines, adapted into the shared graphics layer.
  • MagpieFX shader translation and execution on Metal, so its image filters and upscalers can be used alongside the other effects.

MacLauncher as a tinker tool

I guess the main "philosophy" of MacLauncher is that these are your games, locally, and the job of MacLauncher is to help you do whatever you want with them, i.e. to give the user maximum control over everything possible. As such, the whole model is that MacLauncher uses local files, downloads what you want via version managers, and offers very fine-grained settings. Some things I want to highlight:

  • There are very granular settings for most runtimes and game types. I generally like passing all parameters in so you can set whatever launch flags you want, basically, anything the runtime (or graphics or whatever) allows, you can set. You can also set custom launch flags. Or for example, every game lets you disable network access.
  • Whenever possible, for everything (runtimes, games, graphics, accounts, whatever), I try to make the version management as robust as possible. Any downloadable runtime versions can be selected and used, you can manage multiple google accounts for google play or steam accounts for steam integration or whatever, we try to detect what runtime version a game uses as much as possible, etc etc. In short, you can always control exactly what version of everything you use, which is important for compatibility (but we also try to make the defaults as seamless as possible).
  • There is a huge host of "tools"—stuff like decompilers/asset viewers, save editors, cheats (especially for RPGMaker and Ren'Py games where a universal cheat is possible)—for as many game types as we could find them for. Most runtimes will have some type of extraction available, once again see MODULES.md for details.
  • There is also a very convenient storefront integration. Currently, we support Steam, GOG, Epic, Itch.io, Google Play, and F-Droid/IzzyOnDroid, and you are able to download any games you own (or are free) from MacLauncher itself. The special part about this feature is that, as much as possible, we allow you to download whatever version of games you want. For example, the Steam launcher might not allow you to download Windows versions of a game on mac, but MacLauncher lets you download whatever you want, including Windows, or Linux, or mac 32-bit, or any previous version of the game if you have the depot ID (e.g. through SteamDB). Or for example, you can sign in to however many accounts you want and are not restricted to one account.
  • MacLauncher will never have user-hostile anti-features, or violate privacy. Every single network call is from a specific user interaction (e.g. refreshing upstream versions of stuff), without any background network calls or network call from navigating to some tab. There is no telemetry either: the diagnostics MacLauncher records go only into a log file on your Mac (Help → Show Log in Finder), for your own troubleshooting.

Development

MacLauncher is built on Electron. Yes I know, Electron bad, Electron waste RAM in RAM crisis, Electron = npm supply chain attacks and left pad and react bloat, etc. Believe it or not, however, Electron was actually a conscious decision for this project for the following reasons (possibly cope):

  • So browser-based games (a significant chunk of games) can play without external runtime downloads.
  • Because I might want to port this to Linux or Android (maybe even parts to iOS) in the future and some sort of a shared codebase would be nice.
  • Because the launcher actually doesn't matter that much for performance: after importing games, you don't actually need to use the Electron launcher at all, you can just save the game config as a .command and open it without going through Electron UI at all.
  • As a bonus, we can have a demo on the website!

Anyways, the requirements for dev are Node.js 22.19+, 24 or 26 and pnpm. The source setup commands are:

git clone https://github.com/procrastinine/maclauncher.git
cd maclauncher
node scripts/init-submodules.cjs
pnpm install --frozen-lockfile
pnpm dev

To update, use git pull --no-recurse-submodules, node scripts/init-submodules.cjs and pnpm install --frozen-lockfile.

To build, use pnpm package:mac.

I am trying to minimize supply chain attacks here, so usually packages must be at least 1 week old for me to include. Therefore I would call this safer to install and run than most Node.js projects, but out of caution, I do most development on a VM.

Launcher data and installed runtimes live in ~/Library/Application Support/maclauncher/. Logs are in that folder too: the launcher's own log is logs/main.log (Help → Show Log in Finder opens it), and each game keeps its runtime and tool logs in games/<game ID>/logs/. pnpm launch --game /path/to/game --wait launches a game without the library window; --inspect reads its metadata.

To keep the core launcher itself as light as possible, there is the accompanying project MacLauncher Builds for runtime binaries and the custom builds that should be used for MacLauncher (you should use these through the "Runtimes" panel in the UI). Everything we build in MacLauncher Builds is built through automated GitHub actions and is verifiable, so you can confirm I didn't sneak anything into the binaries outside of what is open-source in the repo itself (how to check).

MacLauncher is alpha software! Things might be unstable or stupid, and it is heavily written with LLMs. Everything "works on my computer" and I tried to support as many macs as possible (macOS versions, and Intel as well as Apple Silicon), but I only have 1 mac to test on other than GitHub Actions mac VMs so I cannot guarantee that it works on systems very different from mine even if I tried my best...

Docs

License

See attributions for what existing projects I used and the licenses they have (mostly open source stuff). MacLauncher itself is MIT licensed.

About

Native runtime system, graphics/effects layer and tinker tool for Mac: play Windows, PS5, Switch, Android, iOS and 32-bit games on macOS/Apple Silicon without Wine or an emulator (RPG Maker, Ren'Py, GameMaker, Godot, Unity, visual novels…), with ReShade, Lossless Scaling (LSFG) frame generation, DLSS, FSR, XeSS, MetalFX upscaling and GPU shaders.

procrastinine.github.io/maclauncher/

Topics

32-bitandroid-gamesapple-silicondlssframe-generationfsrgamemakerlossless-scalinglsfgmac-gamingmacosmetalfxnintendo-switchps5renpyreshaderpg-makerupscalingvisual-novelxess

Resources

Readme
MIT license
Activity

Stars

3 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages