https://www.apple.com/macbook-pro/proled-xdr-display/

Apple just announced the new MacBook Pro, and CONTROL Resonant is already featured on the official product page as one of the games showcased.

• "CONTROL Resonant coming to macOS. Release date subject to change. See developer website for current release information."

Looks like we'll be getting our hands on it soon!

Been working on a tool that takes games you own (Switch, Xbox 360, PS4, Windows and old 32-bit iOS games) and turns each one into a native arm64 app. About 20+ are playable right now; full list coming with release. When the community fixes their favorite games, I wire the fix into the engine so everyone benefits. Releasing soon. What would you want to see first?

I thought C2077 would be unplayable on my M1 Mini/16 GB, but I was wrong, this port is incredible. I even pushed it a little too far with 1080p resolution; there were some FPS drops here and there, but the fact that this works on the first M chip is crazy.

Access it here: https://github.com/metalsharp/MetalSharp-Wine

Use it in MetalSharp 1.0.0 (7 Months in the Making); https://github.com/metalsharp/MetalSharp/releases/tag/v1.0.0

As usual, thanks for the work Crossover does on Wine to make this possible.

Metalsharp Wine is an Arm64 / Aarch64 / Arm64EC / X86_64 / I386 & WoW64 Wine 11.20 that runs x86_64 and I386 & WoW64 through FEX, requiring no Rosetta to run. It is developer signed / notarized, working on MacOS 26.4 and beyond. It is currently in an early-access state.

Graphics Routes:

- Metalsharp-Developed VKD3D-Proton D3D12 on MacOS with a custom built universal MoltenVK 1.4.3; Tested games include Dragon's Dogma 2, God Of War Ragnarock, PEAK, and more on FL 12_2. Someone got Minecraft bedrock working with this.

- Mullion (Dxmt Fork) including D3D12 FL 12_2 Support, running D3D12 / 11 / 10. It has been tested against God of War Ragnarock, PEAK, Red Dead Redemption 2, and more.

- GcenX Dxvk-Macos; DXVK for MacOS rebuilt as Arm64x dlls for D3D11 / 10 / 9 through Vulkan -> Metal.

- OpenGL: WineMetalGL 3.7.0 for OpenGL 1.0 -> 4.6 on Metal for Older games, including GLES 2 -> 3.2 support.

Included Features;

- Pairs with WineForge to provide Rockstar Launcher / Ubisoft Connect / Battle Net loading (WFDXCompat), Mouse / Full-screen Wine issue fixes, and WFUSync (upgraded Msync).

- Ffmpeg and Gstreamer

- Gecko / Inno-Extract / Java support for normal Windows programs.

- Msync (WFUsync) / Reduced x87 Precision enabled by default.

- Wine Mono 11.3.0 for .Net

- Controller support (Xinput / Dinput)

And much more.

Credits;

Gcenx DXVK - MacOS: https://github.com/Gcenx/DXVK-macOS

WineForge; https://github.com/Alien4042x/WineForge

VKD3D-Proton MacOS: https://github.com/metalsharp/VKD3D-Proton-MacOS

Mullion: https://github.com/dttdrv/mullion

WineMetalGL: https://github.com/metalsharp/WineMetalGL

As usual, it will be free to use, forever. I hope this helps some people and this is my way of giving the community something new and working, without a single dollar needed from your pockets. This is what I love to do. It's that simple. However, I expect to see downvotes for free and open sourced work, and I refuse to be bothered.

I added a new version of FSR 4.1.2 Lite and achieved maximum performance (at least for int8 calculations)(m5-m6)

I also made sure that FSR 4 could be easily downloaded, because last time I got criticized for having a “complicated installation”

I’ll also explain why this is necessary - FSR 3 is just an algorithmю it tries to hide the fact that the resolution is poor. FSR 4 is AI that adds details, and it looks much more like the original resolution. You can watch a video comparing FSR 3 and FSR 4. many people say it’s better to set FSR 4 to performance rather than FSR 3 to quality

In terms of FPS, FSR 4 at balance provides roughly the same FPS as FSR 3 at quality (on m5)

https://github.com/UzenUPoZiTiV4ik/fsr4-native-macos

For the past few weeks I've worked on Recomp Toolkit, a free, open-source app for bringing older Windows PC games to Apple Silicon Macs.

It's a static recompiler for windows x86 games into native ARM code, you bring your own app and get a standalone Mac app you can launch directly. I've been inspired by Porting Kit for the desktop app itself, but the toolkit is generic.
It's not magic compatibility for every Windows game. Each game needs (a little) dedicated work, and you need a specific supported version of the original files.

Currently supported:

• Black & White
• Spore: Galactic Adventures
• Civilization IV: Beyond the Sword
• Ghost Recon
• Railroad Tycoon 3
• 4x4 Evolution 2

You can also use the kit generically to port other games, though the App doesn't have a "manual mode" yet. I'm working on integrating NFS Carbon (different take but close to the one posted here before), and I plan to add support for more D3D7/8/9 games, especially those where wine/sikarugir does a poor job at the moment.

This is still an early release - I've only really tested it on my own computer so far. I'd love feedback, issue reports, & other people contributing fixes.
The repo is fully open-source, forked originally from veritr1x, but i've made significant changes to the translation toolkit & the graphics engine.

App is downloadable from github: https://github.com/wraitii/recomp-toolkit/releases/download/v0.1.0/Recomp.Toolkit.app.zip

Repo on GitHub as well: https://github.com/wraitii/recomp-toolkit

Requires Apple Silicon and macOS 14+, plus Apple's Command Line Tools.
Feel free to ask questions in the comments, happy to explain more about how this works or how this toolkit differs from other similar projects !

It Includes free monitoring of you hardware, CPU, GPU, RAM, and more. There's a gaming section where you can add games and launch them directly from the app. There's also a benchmarking tab to test your device CPU and GPU speeds. The one feature I love is the smart feature which is essentially a CleanMyMac section and it works so well. Oh and you can also connect it to your phone via a mobile web app that you can save and monitor your hardware live in real-time.

If you check it out, let me know what you think and your feedbacks as well. I'm actively updating it and want to know how to improve it better for MacOS.

Here's the download link: https://jerryubah.github.io/Coreloom/

I was looking at the new Macbook Pro with PROLED XDR Display at Apple.com and found that. Yet I looked both in Steam and AppStore but couldn't find the macOS version.

Maybe it's just around the corner since they're advertising it?

The Magic Mouse has one physical button. macOS just checks where your finger is to decide "left" or "right". That causes two problems:

1. You can't left-click while holding right-click. Once the button is down, it's down. There's no second button to press. Games, 3D apps and some pro tools need exactly this chord.
2. There's no middle click. No opening links in new tabs, no closing tabs, no panning in Blender/CAD/maps.

So I built MagicClick, a small menu bar app that reads your fingers on the mouse's touch surface and fixes both.

🖱️ Left + right click at the same time

This is the one I haven't seen anywhere else:

1. Hold the right click like normal
2. Touch the left half of the mouse with another finger. That's a left press. You don't need to click, just touch.
3. Lift that finger to release the left button

So you get both buttons down at once on a Magic Mouse. You can tap for a quick left click, or keep the finger down to hold left while right is still held. Double-clicks work too.

It's smart about which finger counts. Fingers that were already resting on the mouse when you pressed right are ignored, and so is a finger that lands on the right side and slides over. Only a new touch on the left half triggers it, so it doesn't fire by accident.

🖱️ Middle click, your way

• Click with 3 fingers on the mouse (or 4 if you want it harder to trigger). Hold and move to middle-drag.
• Optional 3-finger tap without pressing
• Or make any key the middle button: F13, ⌥F5, Right ⌥ Option, fn/🌐, or media keys like Play/Pause and Mute. Hold the key and move the mouse to middle-drag.
• Got another mouse with side buttons? Map button 4 or 5 to middle click.

✨ Also

• Live view shows your fingers on the mouse in real time, with LEFT / RIGHT / MIDDLE badges for whatever is pressed. It's great for learning the gestures.
• Open at login, pause from the menu bar
• Survives sleep/wake and reconnecting the mouse
• Universal app for Apple Silicon and Intel, macOS 14+
• No network access, no analytics. It's ~1,500 lines of Swift you can read.

⬇️ Download

Free and open source (MIT): https://github.com/codeFi/MagicClick

Grab the DMG from the Releases page and drag MagicClick into Applications.

The app isn't notarized (that needs a paid Apple developer account), so macOS blocks it the first time. To allow it once:

1. Open MagicClick, and click Done when macOS says it can't verify it
2. Go to System Settings → Privacy & Security, scroll down to Security, and click Open Anyway
3. Enter your password and click Open Anyway again
4. In the MagicClick window, click Open Accessibility Settings and turn MagicClick on

Or skip steps 1–3 with Terminal:

xattr -dr com.apple.quarantine /Applications/MagicClick.app

Don't want to trust a download? Build it yourself with one command: ./scripts/build.sh install

Honest notes

• It needs Accessibility permission to change clicks.
• It reads touches through Apple's private MultitouchSupport framework (same as BetterTouchTool and MiddleClick). That's why it can't be on the App Store, and a future macOS update could break it.
• After an update you need to re-allow it in Privacy & Security, because the build isn't signed with a developer certificate.

The middle click on the Magic Mouse was inspired by MiddleClick. The left+right chord, keyboard trigger and live view are new, and it's all written from scratch.

If you play games or use apps that need left+right together, I'd love to hear if it works for you. Bug reports and PRs welcome!

First download the fh2 port from github who did the forza horizon 2 port and get it configured to run...*NOT MY PROJECT so support the original creator for this amazing translation layer*

https://github.com/fladnaG86/FH2-Port-AppleSilicon/releases/tag/v0.1.7

then go to the fh2 port application and click show packet contents and place file as shown in last picture and paste the d3d12.dll to new one downloaded from link below

https://drive.google.com/file/d/1512kECKDzswmY0T3sR0QNZWU4FoJsRsQ/view?usp=drivesdk

NOTE-

may crash if no controller detected

may crash if graphics changed except antialiasing

Performance is great otherwise...similar to fh2

BRING YOUR OWN GAMES...NO GAME FILES

[Now currently trying to run fm5 and fh3 too similarly]

You can now connect an Xbox controller to DSX!

https://apps.apple.com/us/app/dsx-gamepad-companion/id6782121173?mt=12

I am seeing a ton of post and videos of vibe coded mac native ports of games

But i never see detailed info about it is so dam annoying, like anyone care explaining the current situation about these ports? And the current situation of mac native ports? Like the botw and totk native ports, and other platform games ports

Do they run well without stuttering freezes or visual artifacts/glitches ??

Can they be run from start to finish until completed 100%, or the game is gonna brake at some point ?

Wich games really work 100%? Does it even worth the effort to do it? Or the technology is so young that its like Quality Testing rn?

Its so annoying to be flood with these native ports and tools but no info about if they run like their native counterpart, problems, performance issues etc

Due to the lack of this i havent even tried any of those ports i feel they are just garbage and waste of time, every single one of them

Not to mention that people have lost their files, erased their folders or similar bad problems trying to run them

Hey everyone! I’m working on nxnative Easy, an open-source project built on seedds/nxnative.

The original nxnative project provides the engine and game compatibility work. My focus is making the preparation workflow easier to follow:

• A personal game library.
• Game and update identification before compiling.
• Guided preparation with build stages and live logs.
• Editable touch controls on iPhone/iPad. - Extended
• Device installation status and manual save export.
• Mac controllers support (PS4, PS5 and Xbox)
• Integrated iOS installer

Compatibility varies by game, version and device.

You need your own game files and prod.keys, plus an Apple silicon Mac with macOS 26+ and Xcode 26+. No games or keys are included.

Repo: https://github.com/nalancer08/nxnative-easy
Original engine: https://github.com/seedds/nxnative

Metro 2033 Redux (next-gen build): CrossOver / D3DMetal launch crash fix

A tiny dinput8.dll proxy that fixes the next-gen build of Metro 2033 Redux crashing a couple of seconds after launch in CrossOver with D3DMetal:

Unhandled page fault on read access to 0000000000000000 at address 0000000140831E55

Cause

The next-gen build renders in DirectX 11 but runs DLSS/FSR on a separate DirectX 12 device, joined by a DX11→DX12 bridge. That bridge needs D3D11 extended resource sharing, and D3DMetal doesn't support it, so the bridge fails. The game correctly marks DLSS as unavailable, but then runs FSR setup anyway, calls into a DX12 device that was never created, and crashes on a null pointer.

The FSR setup function only checks its own run-once flag. The game's bridge-failed flag sits two bytes after it in memory. Changing the compare's opcode from 0x80 to 0x83 widens it from one byte to four (cmp byte → cmp dword), so it also sees the bridge-failed flag and skips FSR setup. Both versions of the instruction are 7 bytes long, so nothing else moves.

This is the same bug and the same fix as the one found for Metro Last Light Redux. In 2033 Redux the instruction is at RVA 0x831E1F:

80 3D F5 31 7A 00 00 48 8B D9 0F 85    ->    83 3D F5 31 7A 00 00 48 8B D9 0F 85

Why a DLL instead of a hex edit

Note: if you have a DRM free version you can directly change the bytes in metro.exe

2033 Redux's metro.exe is wrapped in Steam's DRM (SteamStub), and all of its code is encrypted on disk. A hex editor can't find the bytes, and editing the encrypted bytes would just corrupt the exe.

The DLL does the same one-byte change in memory, after the game has decrypted itself:

• It forwards DirectInput8Create, the only function the game imports from dinput8, to Wine's real dinput8.dll.
• On load, it starts a thread that waits until all 12 expected bytes are present, then flips 80 to 83. If the bytes never match, it changes nothing.
• It writes metro2033_fsr_fix.log next to metro.exe on each launch.

The exe on disk and the DRM are untouched, so Steam file verification won't remove it.

Install

1. Quit the game.
2. Copy dinput8.dll into the game folder, next to metro.exe. link
3. In CrossOver, select your Steam bottle, open Wine Configuration, go to the Libraries tab, add dinput8, and set it to Native then Builtin.
4. Launch the game from Steam.
5. Check metro2033_fsr_fix.log in the game folder. It should say patched after N ms.

To uninstall, delete dinput8.dll and remove the dinput8 override.

In-game settings

FSR setup is skipped, and DLSS and MetalFX aren't available. Use TSR for upscaling or anti-aliasing.

Compatibility

Built for the metro.exe with this SHA-256 (check with shasum -a 256 metro.exe):

7c35095f27beab83b31914029eca0da07991bba8630ec12ba97eec43ffc60c38

If a game update changes the exe, the log will say expected bytes never appeared (different build?) - not patching, and the crash will come back. The new offset then needs to be found and the DLL rebuilt.

dinput8.dll SHA-256:

b4be51d011b245aca8969e4d55eb42bf05055682f740176f8aed82cd7816f27c

Tested on an M4 Pro with 24 GB, CrossOver 26.3, and the D3DMetal backend.

Build from source

dinput8.c is the full source, about 80 lines. Please read it before running a DLL from the internet.

brew install mingw-w64
x86_64-w64-mingw32-gcc -O2 -shared -s -static-libgcc -o dinput8.dll dinput8.c -Wl,--kill-at

Credits

The root-cause analysis and the 0x80 → 0x83 fix come from the Metro Last Light Redux CrossOver writeup. This project ports that fix to 2033 Redux and applies it at runtime because of SteamStub.

Started out getting Mario Kart 8 Deluxe running on my Mac, then went down the rabbit hole of getting it running on my Apple TV too.

It’s now running locally on an A15 Apple TV 4K, using a controller. No streaming from the Mac. It uses nxnative⁠ to rewrite the Switch executable and provide the compatibility layer needed to run it on Apple hardware. It isn’t a full source decompilation.

The Apple TV took quite a bit of extra work:
tvOS support and controller handling, including fixing the confirm button also sending you back to the Apple TV home screen.

Texture changes and a Mario Kart specific memory patch to stay within tvOS’s app memory limit.
Shader preparation before gameplay to reduce compilation pauses.

Dropping the game’s rendering and presentation to 720p, which made a massive difference. I’m really happy with how it plays now.

The version tested is Mario Kart 8 Deluxe 4.0.1, with DLC. New tracks can still cause shader compilation stutters on their first run, so this is very much experimental.
I’ve also put together a Mac GUI app to make the build process easier: select your own game files, build a tvOS IPA, then transfer the game data to your Apple TV.

GitHub: https://github.com/ltomo2/nxnative-tv-builder

Mac app download: https://github.com/ltomo2/nxnative-tv-builder/releases/tag/v0.2.0

Upstream nxnative project: https://github.com/seedds/nxnative

For this preview, you’ll need an Apple Silicon Mac, macOS 26.6 or later, full Xcode 27 with the tvOS SDK, your own game dump/update and keys, and enough free storage.
Allow roughly 30GB extra for Mario Kart. You’ll also need a controller and a way to sign/install the app on the Apple TV.
The Mac app is an unsigned/notarized experimental preview. The build/export process has been tested, but the complete Sideloadly installation route still needs verification. Other games aren’t guaranteed to work, and the Mario Kart memory patch is specific to its tested executable.

No Nintendo games, keys or game assets are included. Credit to the nxnative developers for the underlying project. This builds on their work with the Apple TV changes and a friendlier Mac interface.

Not a vibecoded launcher, just a vibecoded personal build.

Started out just trying to get the Switch version of Hot Pursuit Remastered running on macOS through NX Native. After a lot of debugging and patching with Codex, I’ve ended up with pretty good personal build.

Features:
-60 FPS, with selectable 3840×2160 16:9 or 5040×2160 21:9 internal rendering.

-Virtually no pop-in with 3× model LOD and ground-cover distance, plus expanded foliage buffers to fix trees disappearing during camera pans.

-Long range reflections, also reducing pop-in.

-Analog Trigger support not present in the switch version.

-A ton of fixes for missing shaders, broken lighting, photo-mode crashes and mismatched car-selection graphics.

-Packaged in a self contained app. One click launch through Steam.

This build is far more optimised than the PC port as it is ARM native. The only knock on it is lack of online play and a stretched 21:9 HUD due to running out of AI tokens. I can share a patch kit that chat spat out if you are wanting to do the build yourself.

Credit to the NX Native developers and masagrator/theboy181 for the existing 60 FPS mod this was adapted from. It’s a personal build, but I thought r/macgaming would appreciate the results.

This one is wild. Zelda-Mobile runs the Switch release of Tears of the Kingdom (v1.4.3) natively on Apple silicon. The game's ARM64 code executes directly on the Apple CPU, the system services are reimplemented, and NVN graphics are translated to Metal. On Mac you can load saves and play scenes with keyboard or an Xbox controller (with rumble), plus audio, cutscenes and 30/60/90 FPS targets. iPad (M1 or newer) gets touch controls, and the iPhone 15 Pro build reaches the title screen. It's still early: shaders stutter on the first visit to a new area, and not every area holds 60 FPS. The repo is source code only, so you need your own game and keys dumped from your own console. Repo: github.com/OJZen/totk-mobile

Who's trying this on an M1 Air?

I'm the developer of The Home County, a village-building game set in the British countryside, available on macOS as well as Windows and Linux.

I've just released cross-platform co-op. Mac players can join friends on Windows or Linux using a join code from the new Co-op tab in the main menu, without setting up a server.

You build and decorate a functioning village, manage your villagers' farming and production, explore the mines and pursue hobbies like fishing and painting. The screenshots show multiplayer in the village, the mines and at home.

Available now in Steam Early Access: https://store.steampowered.com/app/3672100/The_Home_County/

I tried the experimental macOS ARM64 port by xPXavierx and it’s been working well. It’s a static ARM64 recompilation rather than a Rosetta 2 translation, and the launcher prepares the game on first run.
My setup: MacBook Air M4 (16 GB RAM), macOS 26.0.1, your own CUSA01623 v1.02 dump.
What worked:
Controller input works, including vibration.
1080p runs well, and Metal rendering works.
Shader issues are minor so far.
And i got 50-60fps and sometimes 40fps rarely which is better than i expected.
What didn’t:
Anything above 1080p crashes the game for me. I’d like to see this fixed.
I’d like to see more people test on different Macs and report results on the GitHub issues page. Thanks to xPXavierx and the projects it builds on (FelipePrado0’s SpartanPort, shadPS4, and others credited in the README).
Repo: https://github.com/xPXavierx/gow3-macos-arm64

I wanted to play Need for Speed II Special Edition on my M3 Pro Mac, and that turned into a small Apple Silicon compatibility project. It is now playable on my machine, and I have published the port changes and English build instructions on GitHub.

The runtime builds as an ARM64 macOS app, without Wine, Rosetta, or a Windows VM. It uses motor-dev/nfs-recompiled, which translates the original x86 game logic into C++. Credit for that foundation goes to the upstream project; my additions focus on macOS/ARM64 compatibility, input, packaging, and a native cheat panel.

What is included:

• Native Apple Silicon build scripts and an app launcher.
• Working mouse and keyboard menus, plus fixes for mismatched menu text.
• An F12 cheat panel with 59 entries, including FZR 2000, GO vehicles and objects, night mode, and extra cameras.
• A reset action for temporary effects, with saves and settings kept outside the app bundle.
• English documentation and 186 passing isolated checks. These are correctness checks, not an FPS benchmark.

Compatibility so far: tested on an M3 Pro running macOS 27. The current packaged build requires macOS 26 or later because of its SDL3 dependency. The project targets Apple Silicon; I would love reports from M1, M2, M3, M4, M5, and M6 owners. Only the M3 Pro is confirmed so far.

This keeps the original software-rendered graphics and feel. The cheat panel currently has Serbian Latin labels; the GitHub guide explains them in English. It is a build-it-yourself project, and you need your own game data. No game assets or ready-to-play download are included.

Project and instructions:
https://github.com/gromilicx/nfs2se-apple-silicon

Upstream runtime:
https://github.com/motor-dev/nfs-recompiled

If you try it, please share your Mac/chip, macOS version, and what works or breaks. Would love to hear from anyone else who remembers this game!

Wanted to see if a base Mac mini could handle Ghost of Tsushima, and it actually runs. I made a video showing the whole setup.

My setup:

• Mac mini M4, 16GB unified memory, 256GB SSD
• CrossOver 26.3
• F16C fix from PCGamingWiki (without it the game won’t get past the start)

What worked for me:

• Medium graphics settings
• FSR instead of DLSS, since DLSS gave me weird colour issues
• Frame Generation and Dynamic Resolution Scaling OFF during the first katana pickup animation. Once that works properly you can try turning them on.

Performance will vary depending on your Mac, settings and CrossOver version, so this is just what worked on my machine.

Full walkthrough (setup, the fix, settings): https://youtu.be/J7rb-lJUyoU
F16C fix: https://community.pcgamingwiki.com/files/file/3122-ghost-of-tsushima-f16c-instructions-fix/

If you try it on a different Mac, tell me how it runs. I’m curious how it does on M1/M2/M3 and on 8GB machines.

With help from Claude/Codex, I statically recompiled Portal 2’s x86 Linux build into native ARM64 code (~125,000 functions translated to C, then compiled). It’s now a native macOS app.

It's playable and performance seems good. I'm still working on it.

Bonus: the same code runs on iPhone at 60 fps, with portals fired by tapping the back of the phone. Video: https://youtu.be/YWX2BeMnlQI

You need to own Portal 2 on Steam and build it yourself (one setup script, ~10-30 minutes the first time depending on your machine). The repo doesn't contain any game files. Please don’t share built apps. This project is unofficial and not affiliated with Valve.

Repo: https://github.com/kanapitsas/portal2-recomp

Claude thought it would take many weeks but we got it done in two days!

Feedback is welcome.

I am just starting to try to run more games on my Mac. What should I know?