| iOS 16 (2022) |
Common Scenarios Where Popups Are Blocked on iPhones and Mitigation Strategies
Apple’s iOS and Safari browser enforce strict popup-blocking policies to enhance user experience and security. However, legitimate popups—such as checkout confirmations, login modals, or survey invitations—are frequently blocked, disrupting workflows for users and businesses. Below are five real-world scenarios where popups are commonly blocked on iPhones, along with technical workarounds to restore functionality.
Popups are essential for user engagement, security verification, and transaction completion, yet Safari’s default settings often suppress them without clear user control. The following examples highlight critical use cases where popup blocking creates friction:- E-commerce checkout processes – Confirmation popups for payment gateways (e.g., PayPal, Stripe) or shipping options fail to display, leading to abandoned carts.
Multi-factor authentication (MFA) prompts – Login portals (e.g., banking apps, SaaS platforms) rely on popup-based SMS/OTP verifications, which Safari may block as "unexpected dialogs."
Live chat or customer support modals – Websites using JavaScript-triggered chat widgets (e.g., Intercom, Zendesk) are suppressed unless explicitly whitelisted.
Survey or feedback popups – Exit-intent surveys (e.g., Typeform, SurveyMonkey) are often blocked mid-session, reducing data collection efficiency.
Third-party cookie consent banners – GDPR/CCPA compliance popups (e.g., OneTrust, Cookiebot) may be treated as intrusive, even when required by law.These scenarios underscore the need for granular control over popup permissions, particularly for domains requiring interactive elements.
Manual Unblocking of Popups for Specific Domains in Safari
Safari allows users to whitelist domains to enable popups selectively. The process involves navigating to Settings > Safari > Advanced > Website Settings, where individual domains can be configured. Below is a step-by-step description of the workflow:1. Access Safari Settings:
Open the Settings app on iOS.
Scroll down and tap Safari.2. Navigate to Advanced Settings:
Select Advanced at the bottom of the menu.
Tap Website Data (to clear existing entries if needed) or directly proceed to Website Settings.3. Configure Popup Permissions:
Under Website Settings, locate the domain (e.g., `example.com`) and tap it.
Toggle Pop-ups to ON to allow popups for that site.
Alternatively, if the domain isn’t listed, use the search bar to find it or add it manually via Add Website.4. Verify Changes:
Revisit the website and test if popups now appear.
If issues persist, ensure no conflicting Content Blockers (e.g., 1Blocker, AdGuard) are active.Note: Safari’s popup-blocking logic prioritizes user privacy, so even whitelisted domains may suppress popups triggered by non-standard events (e.g., `setTimeout`-based delays).
Developers can diagnose why popups fail on iPhones by inspecting Safari’s Web Inspector for blocked events. The most common indicator is the suppression of `window.open()` or `element.click()` triggers via `event.preventDefault()`.Steps to Test Popup Behavior:
1. Enable Web Inspector:
Connect the iPhone to a Mac and open Safari > Preferences > Advanced > Show Develop menu.
Enable Web Inspector in iOS Settings > Safari > Advanced.2. Inspect Console Errors:
Open the target webpage in Safari and trigger the popup (e.g., clicking a "Buy Now" button).
In Web Inspector (Mac), navigate to the Console tab.
Look for errors such as:
`DOM Exception 10: Not allowed to navigate` (indicates `window.open()` was blocked).
`event.preventDefault()` being called by Safari’s popup blocker.
`SecurityError: Blocked a frame with origin` (cross-origin restrictions).3. Common Fixes:
Ensure popups are triggered by user interaction (e.g., `onclick`, not `onload`).
Use `window.open(url, '_blank', 'popup=yes')` with explicit features.
Avoid `setTimeout` delays; Safari may treat them as programmatic popups.Example Debugging Output:
```plaintext
[Error] Failed to execute 'open' on 'DOMWindow': Blocked a pop-up in a non-user-initiated context.
at HTMLButtonElement. (https://example.com/checkout:42:10)
```
This suggests the popup was blocked due to lack of direct user interaction.
While Safari enforces strict popup policies, other browsers on iOS (e.g., Chrome, Firefox) adopt similar but slightly varied approaches. Below is a comparison of their behaviors and workarounds:
Safari’s popup-blocking mechanisms are deeply integrated into iOS, limiting third-party browser flexibility. However, Chrome and Firefox offer partial customization:
- Google Chrome for iOS:
Behavior: Blocks popups by default but allows whitelisting via Settings > Chrome > Site Settings > Pop-ups and Redirects.
Quirk: Some Chrome extensions (e.g., ad blockers) may override default settings, requiring their disablement.
Workaround: Use Chrome’s Incognito Mode to bypass certain popup restrictions (though not all).- Mozilla Firefox for iOS:
Behavior: Relies on Safari’s WebKit engine, inheriting its popup-blocking logic. No native whitelist option exists.
Quirk: Firefox’s Tracker Protection may interfere with legitimate popups, requiring its temporary disablement.
Workaround: Use Firefox for Android (if sideloaded) for more control, though performance may vary.- Brave Browser (iOS):
Behavior: Blocks popups by default but provides a Shields toggle to allow them site-by-site.
Quirk: Aggressive ad/tracker blocking may suppress even non-intrusive popups.
Workaround: Disable Shields for the domain or adjust privacy settings to "Standard."- Opera Mini:
Behavior: Blocks popups entirely due to its compressed rendering engine, offering no whitelist.
Quirk: Not recommended for popup-dependent workflows.- DuckDuckGo Browser:
Behavior: Inherits Safari’s WebKit restrictions but adds Firefly privacy features that may block popups.
Workaround: Disable Firefly temporarily or use the Private Browsing mode (limited effectiveness).Key Takeaway:
Non-Safari browsers on iOS provide minimal popup customization due to iOS’s underlying WebKit constraints. For critical use cases, Safari’s native whitelisting remains the most reliable method.
While iOS enforces strict popup blocking mechanisms to enhance user security and experience, certain technical methods can temporarily override these restrictions. These approaches vary in complexity, effectiveness, and associated risks. Below are five structured methods, each evaluated for feasibility, potential drawbacks, and implementation steps. Users should assess these options with caution, as bypassing security protocols may expose devices to vulnerabilities.
Private Browsing Mode as a Temporary Bypass
Private browsing (Safari’s "Private" tab) disables some tracking and popup restrictions by isolating session data from the device’s default browser profile. This method does not permanently alter system settings but may allow popups to appear under specific conditions.
Effectiveness and Limitations:
Effectiveness varies by website; some modern sites detect Private Mode and enforce stricter controls.
Does not work for all popups, particularly those tied to device-level policies (e.g., Safari’s built-in blocker).
Session-based; restrictions resume upon exiting Private Mode.Implementation Steps:
- Open the Safari app and tap the "New Tab" button (top-right corner).
- Select "Private" from the bottom menu to enter Private Browsing Mode.
- Navigate to the target website. Some popups may appear, though many will still be blocked.
- To exit, tap "Done" in the top-left corner and confirm closure of the Private tab.
Third-party extensions (e.g., "Popup Blocker Disabler" for Safari or Chrome-based browsers like Kiwi Browser) can disable popup restrictions programmatically. These tools often require sideloading due to Apple’s App Store policies restricting such functionality.Effectiveness and Limitations:
Highly effective for Safari-compatible extensions but limited by Apple’s sandboxing.
Chrome-based browsers (e.g., Kiwi) offer more flexibility but may require manual configuration.
Risk of extension-related malware if sourced from untrusted developers.Installation Steps (Example: Kiwi Browser + Extension):
- Download and install Kiwi Browser from the App Store (supports Chrome extensions).
- Open Kiwi, navigate to
kiwibrowser://extensions, and enable "Developer Mode" in settings.
- Download the
Popup Blocker Disabler extension from a verified source (e.g., Chrome Web Store) and sideload it via Kiwi’s extension manager.
- Enable the extension for the target website via Kiwi’s extension icon (puzzle-piece icon).
Note: Safari’s extension ecosystem is restricted; users may need to jailbreak the device or use alternative browsers for full functionality.
JavaScript Console Commands for Forced Popup Display
Advanced users can inject JavaScript commands via the browser’s developer tools to override popup suppression. This method targets the DOM and requires manual execution per session.Effectiveness and Limitations:
Works for client-side popups but fails against server-side restrictions (e.g., `X-Frame-Options` headers).
Temporary; resets upon page reload or browser restart.
May trigger website anti-bot measures or break functionality.Example Commands and Steps:
- Open Safari, navigate to the target website, and tap "AA" (accessibility shortcut) to reveal the menu.
- Select "Request Desktop Site" (if available) or proceed to enable Developer Tools via Settings:
- Go to Settings > Safari > Advanced and toggle "Web Inspector" to ON.
- Connect the iPhone to a Mac, open Safari on the Mac, and select "Develop > [Device Name] > [Website URL]" to inspect the page.
- In the Web Inspector’s Console tab, execute one of the following commands to force popups:
document.body.style.overflow = 'visible' (removes scroll constraints)window.open('https://example.com', '_blank') (directly triggers a popup)document.querySelector('button[onclick*="popup"]').click() (simulates a popup-triggering button click)
Caution: Some websites use event listeners or CSP (Content Security Policy) to block console modifications. Test commands incrementally.
Third-Party Apps Simulating Desktop Behavior
Applications like iTools or iExplorer (for Mac) can modify HTTP headers or emulate desktop user agents, potentially bypassing mobile-specific popup restrictions. These tools often require a computer connection and may conflict with iOS security frameworks.Effectiveness and Limitations:
Effective for user-agent spoofing but limited by iOS’s app transport security (ATS) policies.
Risk of data exposure if the connection is unencrypted.
May violate terms of service for some websites.Steps Using iTools (Mac Version):
- Install iTools on a Mac and connect the iPhone via USB.
- Select "Network Tools > HTTP Header Editor" and modify headers to include:
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)Accept-Language: en-US,en;q=0.9
- Enable "Proxy Mode" in iTools and configure Safari on the iPhone to use the proxy (Settings > Wi-Fi > HTTP Proxy > Manual).
- Restart Safari and revisit the target site; some popups may now appear.
Alternative: Use Charles Proxy or Fiddler for advanced header manipulation (requires technical expertise).
Jailbreaking for System-Level Modifications
Jailbreaking removes Apple’s software restrictions, allowing installation of tweaks like PopUpBlocker++ (via Cydia/Sileo) or custom Safari modifications. This method is the most comprehensive but carries significant risks, including voided warranty, device instability, and security vulnerabilities.Effectiveness and Limitations:
Near-total control over popup behavior but requires technical proficiency.
High risk of bricking the device or exposing it to malware.
Violates Apple’s terms of service; may trigger activation locks or remote wipe.Steps (High-Level Overview):
- Jailbreak the iPhone using tools like Checkra1n (for A12/A13 chips) or Palera1n (for A14+).
- Install a package manager (e.g., Sileo) and search for "PopUpBlocker" or "UserAgent" tweaks.
- Configure the tweak to disable popup restrictions globally or per-domain.
- Reboot the device to apply changes.
Warning: Jailbreaking nullifies security updates and may expose the device to exploits. Proceed only with verified tools and backups.
Security and Ethical Considerations:
Bypassing popup restrictions may violate website terms of service, trigger legal consequences (e.g., DMCA violations for copyrighted content), or expose devices to malware. Untrusted extensions, JavaScript injections, or jailbreak tweaks often serve as vectors for:- Adware or spyware installation (e.g., via malicious extensions).
- Data exfiltration through unsecured proxies or header modifications.
- Remote code execution if exploiting unpatched vulnerabilities.
Use these methods solely for legitimate purposes (e.g., debugging) and at your own risk. For persistent access, consider contacting the website administrator to adjust their popup policies or using authorized APIs.
Apple’s iOS ecosystem enforces strict popup restrictions to enhance user experience and security, requiring developers to adopt adaptive strategies for compatibility. Web developers must align with Apple’s Human Interface Guidelines (HGUI) while leveraging technical workarounds to ensure seamless functionality across iOS devices. Solutions range from frontend optimizations—such as conditional rendering and viewport adjustments—to server-side redirects that prioritize mobile-optimized flows. Below are structured approaches, including code implementations and comparative analyses of frontend versus backend fixes.
Apple’s guidelines explicitly discourage disruptive popups, particularly those triggered by user interaction (e.g., hover, click) or non-standard methods like `window.open()`. Compliance involves replacing intrusive popups with native iOS patterns, such as:
Modal dialogs (via `alert()`, `confirm()`, or custom UIWebView-based modals) for critical user actions.
Sheet presentations (for iOS 13+) using `UIActivityViewController` or JavaScript’s `showModal()` (deprecated in favor of native APIs).
Push notifications or in-app messaging for non-critical alerts, avoiding modal interruptions.Key Restrictions:
Autoplaying or auto-closing popups are blocked by Safari’s Content Blockers.
`window.open()` for ads or promotional content triggers popup blockers unless served via a trusted domain.
Cross-origin popups (e.g., third-party ad networks) are suppressed unless whitelisted in Safari’s exceptions.
Apple’s Web Content Guide states:
"Avoid using popups or overlays that obscure content or disrupt the user experience. Instead, use native iOS patterns like modal sheets or push notifications."
Frontend Techniques for iOS Popup Detection and Adaptation
Developers can dynamically adjust popup behavior based on device detection and viewport conditions. Below are code snippets and methodologies:1. Device Detection via `navigator.userAgent`
Detect iOS devices to apply conditional logic for popup suppression or alternative UX flows. function isIOS() {
return /iPad|iPhone|iPod/.test(navigator.userAgent) ||
(navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
} if (isIOS()) {
// Disable disruptive popups; use modal sheets or in-app alerts
document.querySelectorAll('.popup-trigger').forEach(el => {
el.addEventListener('click', (e) => {
e.preventDefault();
showNativeModal(); // Custom implementation
});
});
} 2. Viewport and Touch Event Checks
Use `window.matchMedia` to detect touch devices and adjust popup triggers (e.g., replace hover-based popups with tap-based interactions). const isTouchDevice = 'ontouchstart' in window || navigator.maxTouchPoints > 0; if (isTouchDevice) {
// Replace hover-triggered popups with tap or scroll-triggered alternatives
document.querySelectorAll('.hover-popup').forEach(el => {
el.addEventListener('touchstart', showAlternativePopup);
});
} 3. Feature Detection for Popup APIs
Check support for modern APIs like `window.showModal()` (deprecated) or `window.open()` restrictions. function canUsePopups() {
try {
const testWindow = window.open('', '_blank');
if (testWindow && !testWindow.closed) {
testWindow.close();
return true;
}
return false;
} catch (e) {
return false;
}
} if (!canUsePopups()) {
// Fallback to in-app notifications or server-side redirects
showFallbackNotification();
}
Server-Side Solutions for Mobile-Optimized Popup Handling
Server-side redirects or API-based logic can preemptively serve iOS users with popup-free experiences. Common implementations include:1. User-Agent-Based Redirects
Redirect iOS users to a mobile-optimized version of the site where popups are replaced with native components. Example (Node.js/Express): app.use((req, res, next) => {
const userAgent = req.headers['user-agent'];
if (/iPad|iPhone|iPod/.test(userAgent)) {
res.redirect('/mobile'); // Serve popup-free mobile flow
} else {
next();
}
}); 2. Progressive Enhancement via API Responses
Serve JSON responses that conditionally include popup-related data based on the device. Example (PHP): $isMobile = preg_match("/iPad|iPhone|iPod/", $_SERVER['HTTP_USER_AGENT']);
$data = [
'popup_enabled' => !$isMobile,
'fallback_url' => '/mobile-alert'
];
header('Content-Type: application/json');
echo json_encode($data); 3. Feature Flags for Popup Control
Use server-side feature flags to toggle popup behavior dynamically. Example (Firebase Remote Config): firebase.remoteConfig().getAll().then((config) => {
const popupEnabled = config.popup_enabled && !isIOS();
if (popupEnabled) {
triggerStandardPopup();
} else {
triggerFallback();
}
});
Below is a side-by-side analysis of frontend and backend solutions, including trade-offs for scalability, performance, and maintainability.
| Criteria |
Frontend Solutions |
Backend Solutions |
|---|
| Implementation Complexity |
- Moderate; requires JavaScript feature detection and conditional rendering.
- No server changes needed, but may conflict with third-party scripts.
|
- Higher; involves server logic, redirects, or API modifications.
- Centralized control over user experience across devices.
|
| Performance Impact |
- Minimal; client-side checks add negligible overhead.
- May introduce latency if redirects or API calls are involved.
|
- Potential latency from redirects (e.g., HTTP 302).
- API-based solutions add network requests but enable dynamic content.
|
| Maintainability |
- Easier to update; changes confined to frontend code.
- Risk of breakage if third-party libraries override behaviors.
|
- More robust for large-scale apps with shared backend logic.
- Requires coordination between frontend and backend teams.
|
| Scalability |
- Limited to client-side logic; may not handle edge cases (e.g., hybrid apps).
- Works well for static sites or SPAs.
|
- Scalable for enterprise apps with centralized user-agent parsing.
- Supports A/B testing and feature flags across devices.
|
| Compliance with iOS Policies |
- Risk of bypassing Safari’s Content Blockers if not aligned with HIG.
- Requires manual testing on iOS devices.
|
- Better alignment with Apple’s server-side policies (e.g., App Store Review Guidelines).
- Reduces reliance on client-side workarounds.
|
Combine frontend detection (for immediate UX adjustments) with backend redirects (for critical flows like authentication or payments).
Use feature flags to gradually roll out changes and monitor iOS-specific metrics (e.g., popup success rates).
Test on real iOS devices (not simulators) due to Safari’s dynamic
Popup restrictions on iPhones often stem from a combination of iOS-level security policies, browser-specific configurations, and website implementation flaws. While Apple’s ecosystem prioritizes user privacy and security, these measures can inadvertently block legitimate popups, leading to functional disruptions for users and developers. This section provides a structured diagnostic approach, error resolution strategies, and technical fixes to systematically identify and resolve popup-related issues on iOS devices.
To systematically determine whether popup blocks originate from browser settings, website code, or iOS restrictions, follow this structured diagnostic process:
Root Cause Identification Steps:
1. Check Browser-Specific Settings
Verify if popups are globally enabled in Safari/third-party browsers (e.g., Chrome, Firefox).
Test with a secondary browser to isolate browser-specific issues.2. Validate Website Compliance with iOS Popup Policies
Ensure the website uses `window.open()` with `rel="noopener"` or `target="_blank"` for external links.
Confirm the absence of forced popups (e.g., auto-playing or timed popups) that violate iOS’s "unexpected popup policy."3. Assess iOS-Level Restrictions
Check if the issue persists in Private Browsing Mode (indicates cache/cookie interference).
Test on a different iOS version or device to rule out OS-specific bugs.4. Inspect Error Logs and Console Output
Use Safari’s Develop Menu (enabled via Settings > Safari > Advanced) to access Web Inspector and log JavaScript errors.
Look for `SecurityError` or `DOMException` codes related to popup suppression.5. Network and DNS Interference
Rule out VPN/proxy conflicts by disabling them temporarily.
Test on a different network (e.g., cellular vs. Wi-Fi) to eliminate ISP-level blocking.
Common Popup Block Error Messages and Resolutions
Below are 10 frequently encountered error messages on iPhones, their root causes, and corresponding fixes. These errors often appear in Safari’s address bar, console logs, or as modal alerts.
-
Error: "Safari can’t open the page because it’s blocked."
Cause: The website triggered a popup from a user gesture (e.g., `onclick` or `onload` event) without proper timing.
Fix:
- Use `setTimeout()` to delay popups until after the page fully loads.
- Ensure popups are triggered by explicit user actions (e.g., button clicks).
-
Error: "This page is trying to open a popup. To allow this, go to Settings > Safari > Block Popups and turn it off."
Cause: Safari’s default popup blocker is active for the domain.
Fix:
- Temporary: Enable popups for the domain via Settings > Safari > Advanced > Website Data > [Domain] > Edit > Allow Popups.
- Permanent: Request users to adjust settings or implement a fallback mechanism (e.g., redirect to a non-popup alternative).
-
Error: "JavaScript is disabled in your browser."
Cause: Safari’s JavaScript execution is blocked (unlikely on iOS, but possible due to strict CSP headers).
Fix:
- Verify the website’s Content Security Policy (CSP) headers do not block `unsafe-inline` or `eval()`.
- Test with `meta` tags:
-
Error: "This page contains both secure and non-secure items."
Cause: Mixed content (HTTP resources loaded on an HTTPS page) triggers security restrictions.
Fix:
- Audit the website for insecure (`http://`) resources using Safari Web Inspector.
- Update all external links/scripts to use HTTPS.
-
Error: "The page at [URL] was loaded over HTTPS, but requested an insecure resource."
Cause: Similar to the above, but affects popup-specific assets (e.g., iframes, scripts).
Fix:
- Replace all insecure URLs in popup-triggering scripts with HTTPS equivalents.
- Use relative paths for internal resources to avoid protocol mismatches.
-
Error: "Unable to load [resource] due to access control checks."
Cause: Cross-Origin Resource Sharing (CORS) restrictions prevent popup-related assets (e.g., iframes) from loading.
Fix:
- Ensure the server includes proper CORS headers:
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET, POST, OPTIONS - For iframes, use `sandbox` attributes or proxy requests server-side.
-
Error: "This website may be impersonating [trusted site]."
Cause: Safari’s fraudulent website warning (often triggered by popup-heavy sites).
Fix:
- Remove suspicious popups or redirect users to a verified domain.
- Submit the site to Apple’s Web Content Analysis for review.
-
Error: "The operation couldn’t be completed because the application isn’t allowed to access certain data."
Cause: iOS’s App Transport Security (ATS) blocks non-compliant HTTPS configurations.
Fix:
- Update the website’s SSL certificate to use TLS 1.2+.
- Add an exception in the `Info.plist` (for apps) or server configuration:
NSAppTransportSecurity
NSAllowsArbitraryLoads
-
Error: "Popup blocked because it was not triggered by a user gesture."
Cause: The popup was initiated via `window.onload`, `setInterval`, or other non-interactive events.
Fix:
- Restructure code to use explicit user triggers (e.g., button clicks):
document.getElementById("openPopup").addEventListener("click", () => {
window.open("https://example.com", "_blank", "noopener");
});
-
Error: "The page you’re trying to open is not responding."
Cause: The popup URL is malformed, blocked by a firewall, or times out.
Fix:
- Validate the URL structure and test with a direct link.
- Implement a fallback mechanism:
try {
window.open(url, "_blank", "noopener");
} catch (e) {
window.location.href = url; // Redirect as fallback
}
When popup blocks persist despite code-level fixes, system-wide adjustments to iOS, browser settings, or network configurations may resolve the issue. Below are actionable steps categorized by their scope.
Critical Notes:
Backup data before resetting settings or updating iOS.
Test changes incrementally to isolate the effective fix.
Update third-party browsers (e.g., Chrome, Firefox) to their latest versions, as they may include iOS-specific popup handling improvements.
-
Clearing Browser Cache and Website Data
Popups may fail due to corrupted cache or conflicting cookies. Safari’s Website Data feature allows selective clearing:
- Steps:
1. Navigate to Settings > Safari > Advanced > Website Data.
2. Select the problematic domain and tap Edit > Remove.
3. Restart Safari to apply changes.
- Alternative: Use Private Browsing Mode to test if cached data is the issue.
-
Resetting Safari Settings
A full reset restores default configurations, including popup permissions:
- Steps:
1. Go to Settings > Safari > Clear History and Website Data.
2. Confirm to delete all cached data, cookies, and history.
- Note: This does not delete bookmarks or saved passwords.
-
Updating iOS and Browser Software
Apple frequently patches iOS to address popup-related bugs. Ensure the device and browsers are up to date:
- For iOS:
- Settings > General > Software Update > Download and Install.
- For Browsers:
- Update via the App Store or browser’s built-in update mechanism (e.g., Chrome’s menu > Help > About Google Chrome).
- Example: iOS 16.4 introduced fixes for Safari’s
Resolving popup blockages on iPhones requires a balanced approach that respects Apple’s security protocols while addressing functional gaps for users and developers. Whether through manual adjustments in Safari, technical bypasses for testing, or code-level optimizations, the solutions outlined here bridge the divide between restrictive iOS policies and operational needs. For end-users, understanding the nuances of browser settings and diagnostic tools can mitigate frustration, while developers benefit from proactive strategies to design popups that comply with iOS standards. Ultimately, this guide serves as a comprehensive resource to demystify popup restrictions, fostering a more adaptive and user-centric digital environment on iPhone devices.
|
|---|
Leave a Comment
Comments are moderated before appearing. The data you submit is processed according to the Privacy Policy of www.linuxunplugged.com.