RenderFocus Icon

Take Full Control of Apple Silicon.

macOS distributes CPU power fairly. RenderFocus plays favorites. 20+ optimization features: Force background apps to E-Cores, auto-detect performance threats, schedule workflows, monitor RAM & battery — all from your menu bar.

Get RenderFocus

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
Features Built-in
0
New in v1.2
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

Eighteen 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%
Unified Memory

VRAM Without Limits.

Apple Silicon shares memory between CPU and GPU dynamically. RenderFocus gives you real-time visibility into GPU allocations via Metal API.

Live GPU Memory Allocation
GPU Allocated 8.4 GB
0 GB Recommended Max (65%) 32 GB Total
32
GB Total
8.4
GB GPU
23.6
GB Free
Memory Pressure: Low
GPU has plenty of headroom for large renders
How It Works
1
Metal API Query
MTLDevice.currentAllocatedSize returns bytes currently allocated by GPU
2
IOKit Fallback
AGXAccelerator stats via IOKit for system-wide GPU memory usage
3
Real-time Polling
2-second intervals with delta calculations for smooth UI updates
Memory Pressure Thresholds
0-60% — Normal Healthy
60-85% — Elevated Caution
85%+ — Critical Swap Risk
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 · 10,000+ 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.

33
Swift Files
10,000+
Lines of Code
2
Build Targets
Apple Notarized

Choose Your Plan

One license, one device. Full access to every feature.

Monthly

$2.49 /mo

Cancel anytime

  • All 20+ features
  • Future updates
  • Flexible commitment
Most Popular

Lifetime

$24.99 once

Pay once, yours forever

  • All 20+ features
  • Lifetime updates
  • No subscription
  • Best value

Yearly

$11.99 /yr

Save 60% vs monthly

  • All 20+ features
  • Future updates
  • Best recurring value

Secure payment via Paddle. VAT/tax calculated at checkout.

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.

What is Deep Freeze mode?

Deep Freeze goes beyond throttling by sending Unix SIGSTOP signals to background apps. This completely halts their execution (0% CPU), causing macOS to aggressively swap them to disk and free Unified Memory. Use SIGCONT to safely thaw frozen apps. All Apple system processes (Finder, Dock, Spotlight, WindowManager, Control Center, and more) are automatically protected and can never be frozen—your focused app is also always excluded.

How does Memory Purge work?

Memory Purge runs /usr/sbin/purge via the root daemon to clear inactive memory and file cache instantly. This creates a contiguous block of free RAM before your render begins, maximizing what GPU can allocate from Unified Memory.

How accurate is the GPU Memory monitor?

Very accurate. We use Metal API’s MTLDevice.currentAllocatedSize for real-time GPU allocations, with IOKit AGXAccelerator as a fallback. The 2-second polling interval keeps the UI smooth without impacting performance.

Can I use all modes together?

Yes! For maximum render performance: activate Beast Mode for P-Core priority, Deep Freeze resource-hungry background apps, run Memory Purge before starting, and monitor GPU Memory throughout. E-Core Jail can permanently restrict known offenders like Electron apps.

What is Performance Guard? New v1.2

Performance Guard is your Mac’s immune system. It continuously monitors for resource-hungry system processes (Spotlight indexing, Time Machine, iCloud sync, macOS updates) and alerts you with one-tap actions: Throttle to E-Cores, Defer, or Dismiss. Smart Learning adapts to your patterns over time.

How does Smart Scheduler work? New v1.2

Smart Scheduler lets you create time-based automation rules. Set specific days and hours for Beast Mode, Deep Freeze, or any optimization to activate automatically. Perfect for recurring render sessions or scheduled workflows.

What are Workspace Profiles? New v1.2

Workspace Profiles save your complete optimization setup — focus app, Beast Mode, Deep Freeze, fan settings, E-Core Jail list — as a named profile. Switch between Video Editing, 3D Rendering, Coding, or Music Production configs with a single click.

Does RAM Monitor replace Memory Purge? New v1.2

No, they complement each other. RAM Monitor provides real-time memory pressure visualization (Active, Wired, Compressed, Free) with optional auto-purge when pressure exceeds your threshold. Memory Purge is still available for manual one-click clearing.