RenderFocus Icon

Take Full Control of Apple Silicon.

macOS distributes CPU power fairly. RenderFocus plays favorites. Force background applications into Efficiency Cores and dedicate maximum performance exclusively to your active workflow.

Request Beta Access

Requires macOS 13.0+
Optimized for M-series architectures

Apple Notarized
14-Day Free Trial
Scroll to Explore

Not all cores are
created equal.

0
P-Cores Locked
0
Threads Restricted
0
Faster Compilation
Zero
Data Collected
Precision

The Art of Focus.

Interaction meets hardware logic. Toggle the focus mode to see the XNU scheduler route system threads in real-time.

Kernel Thread Router
XNU
Mach_Kernel
P-Cores
E-Cores
THREADS_PRIORITIZED_NODES_0_1
Control Interface
Logo
RenderFocus
Focus Mode Active
Real-time Load
Applications
🎬
Final Cut Pro
PID: 4829
🎯
πŸ› οΈ
Xcode
PID: 9211

Defeat Background Noise

Electron apps, sync engines, and browser tabs constantly interrupt your P-Cores. RenderFocus physically restricts their threads to the E-Core cluster, eliminating micro-stutters.

Workflow Priority

Whether you are compiling massive codebases in Xcode, rendering 3D scenes in Blender, or exporting 8K timelines in Final Cut Pro, RenderFocus ensures your primary tool gets undivided attention.

1-Click Hardware Lock

No complex terminal commands or endless configuration files. Select your target application, hit focus, and watch the XNU scheduler obey your command in real-time.

Interactive

Pick Your Priority.

Select an application and watch RenderFocus redistribute CPU resources in real time.

RF RenderFocus
Select an app to focus
P-Cores: balanced 0 threads restricted
Audience

Built for Professionals.

Developers

Compile Faster.

Lock Xcode or Docker to P-Cores. Prevent background sync engines and browser tabs from extending your build times.

Creators

Uninterrupted Renders.

Keep Blender, Final Cut, or Premiere Pro fed with pure Firestorm power. Background apps get relegated to E-Cores.

Audio Pros

Zero Dropouts.

Give your DAW absolute priority. Eliminate “System Overload” errors caused by background micro-stutters.

Modes

Five Ways to Dominate.

From surgical precision to full system domination. Choose the mode that matches your workflow.

Focus Mode

One App. All P-Cores.

Select your target app, press Focus, and every other process is instantly routed to Efficiency Cores via taskpolicy -b. Your app gets undivided access to the entire Performance cluster.

1-Click Activate Instant Release Auto-Cleanup
🎬Final Cut Pro
P-CORE
πŸ› οΈXcode
E-CORE
🧭Safari
E-CORE
πŸ’¬Slack
E-CORE
Monitor

Live Core Heatmap.

Per-core CPU usage visualization via Mach host_processor_info API. The menu bar icon becomes a real-time heatmap of your silicon.

Menu Bar Heatmap (18Γ—18)
<15%
15-50%
50-80%
>80%
Per-Core Usage
P0
87%
P1
92%
P2
78%
P3
95%
P4
64%
P5
71%
E0
12%
E1
8%
E2
18%
E3
5%
Visualization

Visualize the Scheduler.

See how RenderFocus forcefully evicts background threads from your Performance Cores.

Before RenderFocus
P-Cores
E-Cores
After RenderFocus
P-Cores
E-Cores
Interface

Lives in Your Menu Bar.

One click away. Always watching, never in the way.

Logo
RenderFocus
Focus Mode Active
Session Details
Target Application Final Cut Pro
Process ID PID: 4192
P-Core Allocation 8 / 8 Locked
Background Threads 142 β†’ E-Cores
Core Status
Architecture

Privilege-Separated by Design.

Four layers of isolation ensure your system stays secure while RenderFocus operates at kernel depth.

Menu Bar App

SwiftUI interface running in user-space. Manages AppManager, AutoFocus, CoreVisualizer, and FanMonitor.

LSUIElement Β· Hardened Runtime

XPC Channel

Persistent NSXPCConnection via Mach IPC. Auto-reconnects on invalidation with thread-safe resume guards.

Mach Service Β· NSLock Protected

Root Daemon

LaunchDaemon at /Library/PrivilegedHelperTools/. Runs taskpolicy, SMC writes, jail monitoring.

root:wheel Β· KeepAlive

XNU Kernel

Darwin kernel receives taskpolicy -b/-B QoS hints. Scheduler routes threads to P-Core or E-Core clusters.

QoS Classes Β· Mach Scheduler
App β†’ Helper

NSXPCConnection via Mach service com.renderfocus.helper

Helper β†’ Kernel

/usr/sbin/taskpolicy -b/-B -p <PID> via Process.launch

App β†’ SMC

Direct IOKit access (read) Β· Root daemon for write operations

Benchmarks

The Mathematics of Focus.

WebKit Compilation Time (Xcode)

Without
14m 20s
With RF
11m 45s

Heavy 3D Render (Blender)

Without
8m 10s
With RF
6m 55s

Benchmarked on M3 Max Β· 16-core CPU Β· 128GB Unified Memory

Installation

Under the Hood.

From first launch to kernel-level control in 60 seconds. Here's exactly what happens when you install RenderFocus.

Phase 1 β€” First Launch Sequence
EULA Agreement
Beta disclaimer & liability terms. App won't proceed without acceptance.
hasAcceptedEULAv2
8-Step Wizard
Silicon education, mode demos, architecture diagram, daemon install.
"Skip to Install" available
bootstrapApp()
8 managers initialized. Menu bar icon appears. Ready to focus.
NSStatusBar.system
install_helper.sh β€” root
$ osascript -e 'do shell script "..." with administrator privileges'
Installed Files
/ (root)
Library/
LaunchDaemons/
com.renderfocus.helper.plist 644 root:wheel
PrivilegedHelperTools/
com.renderfocus.helper 544 root:wheel
Source (App Bundle)
RenderFocus.app/
Contents/MacOS/
RenderFocusHelper bundled binary
LaunchDaemon Configuration
<key>Label</key>
<string>com.renderfocus.helper</string>
<key>RunAtLoad</key> <true/>
<key>KeepAlive</key> <true/>
<key>MachServices</key> { ... }
Phase 3 β€” Connection Verification
After install, the app pings the daemon up to 5 times with exponential backoff:
1
800 ms
2
1,200 ms
3
1,600 ms
4
2,000 ms
5
2,800 ms
XPC Connection Pool
Mach Servicecom.renderfocus.helper
Connection TypeNSXPCConnection (privileged)
Thread SafetyNSLock + safeResume()
Auto-ReconnectinvalidationHandler
Daemon Capabilities
taskpolicy -b/-B
SMC fan writes
Jail monitoring
Beast Mode sweep
PID cleanup
Process discovery
Security Model
App Entitlements
app-sandbox = false
automation.apple-events = true
hardened-runtime = enabled
Daemon Permissions
binary: 544 (r-xr--r--)
plist: 644 (rw-r--r--)
owner: root:wheel
Code Signing
identity: Developer ID
team: Verified Team ID
notarized: stapled βœ“
Footprint

Featherweight by Design.

RenderFocus is built to observe, not consume. Near-zero CPU impact with intelligent polling intervals.

~30 MB
App Memory

SwiftUI menu bar app with live core visualizer, fan monitor, and all 5 power modes.

~5 MB
Daemon Memory

Minimal root daemon. Handles taskpolicy, SMC writes, jail monitoring, and Beast Mode sweeps.

<0.1%
CPU Impact

Adaptive polling: 3s active, 15s background. Heatmap cached with hash-based invalidation.

Adaptive Polling Intervals
3s
CPU & Fan (Active)
15s
CPU & Fan (Background)
5s
Jail Monitor (Daemon)
1s
Heatmap Debounce

Engineered for Performance.

Low-level Darwin Integration Β· 5,697 Lines of Swift

XNU Kernel Integration

Interfaces with Darwin's taskpolicy(2) API, modifying QoS classes and thread priorities. Uses taskpolicy -b/-B -p <PID> for E-Core/P-Core routing via the Mach scheduler.

Mach CPU Monitoring

Per-core usage via host_processor_info(PROCESSOR_CPU_LOAD_INFO). Delta-based tick calculation with wrapping subtraction handles counter overflow. P/E topology via sysctl.

Secure Daemon Architecture

Privilege-separated XPC daemon installed as LaunchDaemon. Root-level operations include taskpolicy, SMC fan writes, and jail monitoring. Binary at /Library/PrivilegedHelperTools/ with 544 permissions.

SMC Hardware Bridge

Thread-safe IOKit access via NSLock. Supports both AppleSMCKeysEndpoint (M3+) and AppleSMC (M1/M2). 10-key temperature fallback chain.

17
Swift Files
5,697
Lines of Code
2
Build Targets
βœ“
Apple Notarized

Frequently Asked Questions

Why RenderFocus require biometric authentication (Touch ID)?

Modifying thread allocations across different user processes requires kernel-level privileges. We use Apple's secure SMAppService to authorize these changes safely.

Will this cause my Mac to overheat?

No. RenderFocus manages thread scheduling, not hardware voltage. Apple's built-in thermal throttling and power management remain 100% active and untouched.

How is this different from just closing background apps?

Closing apps disrupts your workflow. RenderFocus allows you keep your background apps openβ€”they just run silently on the Efficiency Cores without stealing resources.

Does it work on Intel-based Macs?

No. RenderFocus is strictly designed for the asymmetric core architecture (Performance & Efficiency clusters) unique to Apple Silicon (M-series) processors.

Is my data collected?

Absolutely not. RenderFocus operates entirely offline. There are no telemetry trackers, no analytics, and no phoning home.

What is Beast Mode vs Auto-Focus?

Auto-Focus activates when your target app comes to the foreground using NSWorkspace. Beast Mode is more aggressive β€” the daemon sweeps all GUI processes system-wide and throttles everything except your focus app, with a 5-second cooldown to prevent cycling.

How does E-Core Jail work?

E-Core Jail permanently restricts selected apps to Efficiency Cores, even across app restarts. The daemon monitors every 5 seconds and re-applies throttling to any jailed app that relaunches. It works independently of Focus Mode.

Is the fan control safe?

Yes. Fan control uses direct SMC access through IOKit. A built-in safety floor automatically sets fans to 2500 RPM if CPU temperature exceeds 85Β°C. Apple’s thermal protection remains fully active underneath.