HP Uses Intel SMM to Hijack Windows Boot for Outlook Calendar Display
Cathode Ray Dude - CRD
HP resorted to bare-metal EFI applications and risky SMM firmware hijacks because PC hardware commoditization left pre-boot execution as the only proprietary space to invent superficial product differentiation.
AI-assisted summary of Quick Start, Episode 7: Crimes... And Felonies. — original source. Check the original for full context.
Source published:
Key ideas
- HP's QuickLook utility on the EliteBook 8440p bypassed the complexity of Microsoft Exchange integration by operating entirely offline, using a Windows Outlook plug-in to sync data via flat XML files stored on a dedicated FAT32 partition. (11:27)
- QuickLook was built as a native EFI application running directly on the system's core platform firmware, utilizing UEFI's native file system awareness and Graphics Output Protocol (GOP) to boot in under eight seconds without an operating system. (15:30)
- HP's Daystarter utility hijacked the Windows boot sequence to display calendar data by abusing System Management Mode (SMM), a highly privileged 'Ring -2' execution state that preempts the OS kernel to control the display frame buffer. (36:24)
- The extreme engineering behind these pre-boot environments highlights late-2000s PC market saturation, where OEMs resorted to complex firmware-level hacks to differentiate highly commoditized 'jellybean' hardware. (44:32)
Detailed notes
## Background Published on YouTube by Cathode Ray Dude (CRD) on March 25, 2024, this seventh installment of the Quick Start series examines HP's peculiar entries in the fast-boot computing craze. As the video's description summarizes, HP looked at existing fast-boot implementations across the industry and concluded they could do worse, ultimately delivering on that promise.
## TL;DR The video deconstructs two bizarre firmware-level utilities found on a 2010 HP EliteBook 8440p: QuickLook and Daystarter. QuickLook is revealed to be a custom, offline Microsoft Outlook clone running directly on bare metal as a signed UEFI executable that reads cached XML data from an auxiliary FAT32 partition. Daystarter escalates into a genuine technical horror story, abusing System Management Mode (Ring -2) to hijack the display frame buffer, intercept keyboard input, and pause the Windows boot process just to display static calendar JPEGs. The host uses these astonishingly complex hacks to argue that PC hardware has reached functional saturation, forcing corporate OEMs into reckless firmware gimmicks to fabricate product differentiation.
## Atmosphere & style The presentation blends meticulous low-level technical dissection with acerbic, bewildered humor and escalating disbelief. Viewers are guided through a gripping architectural mystery that shifts from nostalgic amusement over vintage enterprise software into genuine technical dread once the mechanics of System Management Mode are uncovered. Delivered with the energy of a passionate, unhinged whiteboard lecture, the video transforms an autopsy of obscure corporate bloatware into an incisive, existential critique of technology commoditization.
## Bulletin - [11:27](https://www.youtube.com/watch?v=ssob-7sGVWs&t=687s) HP's QuickLook utility on the EliteBook 8440p bypassed the complexity of Microsoft Exchange integration by operating entirely offline, using a Windows Outlook plug-in to sync data via flat XML files stored on a dedicated FAT32 partition. - [15:30](https://www.youtube.com/watch?v=ssob-7sGVWs&t=930s) QuickLook was built as a native EFI application running directly on the system's core platform firmware, utilizing UEFI's native file system awareness and Graphics Output Protocol (GOP) to boot in under eight seconds without an operating system. - [36:24](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2184s) HP's Daystarter utility hijacked the Windows boot sequence to display calendar data by abusing System Management Mode (SMM), a highly privileged 'Ring -2' execution state that preempts the OS kernel to control the display frame buffer. - [44:32](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2672s) The extreme engineering behind these pre-boot environments highlights late-2000s PC market saturation, where OEMs resorted to complex firmware-level hacks to differentiate highly commoditized 'jellybean' hardware.
## Key takeaways - [00:00](https://www.youtube.com/watch?v=ssob-7sGVWs&t=0s) The HP EliteBook 8440p featured three separate physical power triggers mapped to three distinct software environments: Windows 7, QuickWeb (Splashtop Linux), and QuickLook (an offline EFI application). - [00:00](https://www.youtube.com/watch?v=ssob-7sGVWs&t=0s) QuickWeb, a stripped-down Splashtop Linux distribution, booted scarcely faster than Windows 7 on a standard 7200 RPM drive and was rendered obsolete by standard ACPI standby and hibernation states. - [04:02](https://www.youtube.com/watch?v=ssob-7sGVWs&t=242s) QuickLook functioned as an offline, standalone clone of Microsoft Outlook that booted in four to eight seconds but lacked any network stack, Wi-Fi, or Ethernet drivers. - [11:27](https://www.youtube.com/watch?v=ssob-7sGVWs&t=687s) To avoid the liability and complexity of direct Microsoft Exchange synchronization, HP used a Windows Outlook plug-in to export and import data via flat XML files on a FAT32 partition. - [15:30](https://www.youtube.com/watch?v=ssob-7sGVWs&t=930s) QuickLook is a native EFI application (QuickLook.efi) executed directly by the motherboard firmware before any operating system kernel loads. - [18:52](https://www.youtube.com/watch?v=ssob-7sGVWs&t=1132s) The transition from legacy BIOS to UEFI enabled file-system-aware booting (via GPT and FAT32) and provided standard protocols (like GOP) to run sophisticated pre-boot applications. - [24:15](https://www.youtube.com/watch?v=ssob-7sGVWs&t=1455s) HP cryptographically signed the QuickLook.efi binary to prevent unprivileged Windows malware from replacing the pre-boot executable on the accessible FAT32 partition. - [29:50](https://www.youtube.com/watch?v=ssob-7sGVWs&t=1790s) HP Daystarter attempted to display Outlook calendar information during the Windows boot sequence, allowing users to pause the boot process using interactive function keys. - [36:24](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2184s) Because standard operating systems do not allow third-party software to preempt the kernel during boot, HP implemented Daystarter using System Management Mode (SMM), or 'Ring -2'. - [40:26](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2426s) SMM is an incredibly powerful, unmaskable hardware execution state designed for transparent power management that can freeze the operating system kernel without its knowledge. - [41:28](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2488s) Daystarter's SMM implementation used fragile memory-sniffing heuristics to hijack the display frame buffer, risking severe system instability or unbootable states if Windows updates altered memory layouts. - [44:32](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2672s) The creation of complex pre-boot utilities like Daystarter was driven by market saturation and the commoditization of PC hardware, forcing OEMs to seek differentiation through firmware-level gimmicks. - [49:56](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2996s) Because OEMs do not manufacture the core 'jellybean' silicon components, their engineering efforts are often restricted to external chassis design and pre-boot firmware customization. - [56:42](https://www.youtube.com/watch?v=ssob-7sGVWs&t=3402s) Although these pre-boot features represented a massive engineering effort, they were rendered completely obsolete by the rapid rise of modern smartphones like the iPhone 4.
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=ssob-7sGVWs&t=0s) QuickWeb Recap and the Premise of Fast Booting
The host opens by welcoming viewers back to *Quick Start*, a series focused on the fast-booting laptop craze of the late 2000s—though this episode features an HP EliteBook 8440p released in 2010. Looking back across the entire series, the host reflects that “the whole fast booting thing never really got delivered on and also maybe the problem they were trying to solve never really existed to begin with.” Rather than laboring through another formal recap, the host jumps straight in.
The 8440p previously appeared briefly in Episode 2 to demonstrate HP QuickWeb. QuickWeb was simply HP’s custom branding of Splashtop OS: a severely stripped-down Linux distribution that lived inside a file within a folder on the hard drive. About half a dozen PC and motherboard manufacturers licensed Splashtop for a few years before abandoning it entirely because “it was absolutely goddamn useless.”
Activating QuickWeb requires holding an invisible, finicky capacitive button above the keyboard for a full second. Once booted, it presents nothing more than an isolated web browser. Because its built-in TLS root certificates have long since expired, it cannot even safely connect to modern websites, making it impossible to demo anything meaningful.
```mermaid flowchart TD accTitle: Dedicated Hardware Buttons on the HP EliteBook 8440p accDescr: Three separate power triggers launch three distinct software environments on the laptop.
subgraph Controls["Physical Buttons"] B1["Standard Power Button"] B2["Capacitive QuickWeb Button"] B3["Capacitive QuickLook Button"] end
subgraph Targets["Target Environments"] T1["Windows 7 (Full OS)"] T2["QuickWeb (Splashtop Linux Browser)"] T3["QuickLook (Offline EFI Application)"] end
B1 --> T1 B2 --> T2 B3 --> T3 ```
- **Boot Performance:** QuickWeb boots scarcely faster than a standard OS. On a standard 7200 RPM mechanical hard drive, Windows 7 boots in approximately 30 seconds—only about 10 seconds slower than QuickWeb. - **Standby vs. Fast Boot:** In 2010, both Windows 7 and desktop Linux fully supported ACPI standby and hibernation. Resuming Windows from standby on the EliteBook takes a negligible fraction of a second, completely invalidating the need for a secondary browser-only operating system. - **Hardware Configuration:** The test machine ran on its factory-spec 7200 RPM spinning platter hard drive; HP also offered factory SSD options that would have delivered superior boot times regardless of corporate IT bloatware.
---
[04:02](https://www.youtube.com/watch?v=ssob-7sGVWs&t=242s) Feature 1: QuickLook
While searching HP's website for original drivers to restore the bare hard drive on this EliteBook, the host kept encountering references to a separate utility called "QuickLook." Far from being a synonym for QuickWeb, QuickLook had its own dedicated capacitive button alongside the standard power button and the QuickWeb button. This design gave the HP EliteBook 8440p three separate power buttons mapped to launch three entirely different environments.
Pressing the QuickLook button boots the system in four to eight seconds—making it arguably the fastest-booting environment featured across the entire run of *Quick Start*. Yet any hope that it might redeem the hardware is quickly dashed: “It gives me no joy to report that's a lie it gives me great joy to report this but no it will not save this machine.”
QuickLook is essentially a barebones, standalone clone of Microsoft Outlook. The interface boots directly into a split dashboard showing a calendar agenda and a task list. Side tabs allow the user to navigate between classic Outlook categories:
- **Calendar & Contacts:** Users can create calendar events, assign attendees, and add new contacts (demonstrated by the host adding an entry to buy Oracle and adding his three cats to the contact directory). - **Tasks / To-Do:** Standard task creation and checking. - **Email Interface:** Displays cached email, but with severe functional defects. Attachments such as JPEGs, Word documents, or PDFs cannot be opened or interacted with. Large inline images cannot be scaled, resized, or scrolled smoothly; high-resolution photos are cropped into tiny fragments of cat ears and paws. - **Composing Messages:** New messages can only be written in plain text with an optional signature. Clicking "Send" does not dispatch the email; it routes it silently into the Drafts folder.
The most baffling limitation of QuickLook is that it operates completely offline. The user interface has no setup menu, no network configuration screens, and no support for Wi-Fi or Ethernet whatsoever. It is impossible to connect to the internet, receive incoming mail, or send outbound messages directly from the utility.
---
[09:15](https://www.youtube.com/watch?v=ssob-7sGVWs&t=555s) QuickLook Under the Hood
The absence of network drivers and the blinding four-to-eight-second boot time off a 7200 RPM spinning disk eliminate the possibility that QuickLook is running a standard operating system. Even an optimized Linux kernel paired with X11 graphics drivers would struggle to reach an interactive desktop that quickly on mechanical storage.
The host reveals the truth behind this bizarre utility: “The answer is nothing we are running no operating system right now.”
Rebooting into Windows 7 and launching the full Microsoft Outlook client exposes how QuickLook actually works behind the scenes. QuickLook is not an independent application; it is merely an offline staging interface tethered directly to Outlook's local data files. When Windows boots: - The tasks and calendar events created in QuickLook appear immediately inside Outlook. - New contacts created in QuickLook sync straight into the primary Outlook address book. - The unsent draft message composed inside QuickLook sits waiting in the Outlook Outbox, ready to be sent over the network once Windows establishes a live connection.
This architecture was HP's workaround for enterprise mail environments. In corporate settings, Outlook interfaces with Microsoft Exchange—a massive, feature-heavy platform with intricate security policies. Building a standalone third-party client with its own networking stack, Active Directory authentication, and complete Exchange protocol compatibility would have been an astronomical engineering challenge. By stripping networking out entirely and treating the offline utility as an asynchronous cache for Outlook, HP bypassed the complexity of the Exchange server entirely.
[11:27](https://www.youtube.com/watch?v=ssob-7sGVWs&t=687s) Outlook Synchronization and the HP Tools Partition
Attempting to build a completely independent, generic IMAP or Exchange email client for QuickLook would have resulted in an unmanageable synchronization nightmare. Users would be forced to download emails twice, manage separate domain credential resets in two places, and deal with unsent offline outbox messages that vanish between environments. Furthermore, writing a fully featured email client from scratch is notoriously difficult, and reverse-engineering Microsoft Outlook's massive, proprietary data files carries catastrophic risks. As Cathode Ray Dude explains:
> “Also the Outlook profile could be 40 gigs or 100 gigs and I don't know if there's any approved method for a thirdparty app to edit an Outlook data store so if you just try to wing it and screw up you could get sued for billions in damages and probably lose.”
HP circumvented this liability by avoiding direct access to the Outlook profile altogether. Instead, the QuickLook installer attaches a custom plug-in to an existing installation of Outlook 2003 or Outlook 2007. Because Outlook plug-ins utilize Microsoft's approved, safe APIs to read and write profile data, the plug-in cleanly bridges the gap while Windows is running. A dedicated toolbar in Outlook allows users to configure capture frequency and data volume, or manually trigger an "Export Now" command.
```mermaid flowchart TD accTitle: QuickLook Data Flow Architecture accDescr: Flow diagram showing how the Outlook plugin exports data to XML files on the HP Tools partition, which QuickLook reads and writes before syncing back.
subgraph WindowsOS ["Windows Environment"] OL["Microsoft Outlook (2003 / 2007)"] PI["QuickLook Outlook Plug-in"] OL <-->|"Official APIs"| PI end
subgraph DiskPartition ["HP_TOOLS Partition"] DIR["data_directory.xml"] STORE["Email, Calendar, Tasks & Contacts XMLs"] DIR --> STORE end
subgraph PreBoot ["Pre-Boot Environment"] QL["QuickLook Application (EFI)"] end
PI -->|"Export cache (Base64 UTF-16LE)"| STORE STORE -->|"Read cached PIM data"| QL QL -->|"Write queued outgoing edits"| STORE STORE -->|"Import on next launch"| PI ```
The exported data is stored directly on a secondary hard drive partition labeled `HP_TOOLS`. Inside a dedicated `QuickLook` folder, the software generates a collection of plain XML files, indexed by a master file named `data_directory.xml`. This index catalogues distinct files for contacts, tasks, calendar items, and emails (such as `ac93.xml`). Within these files, standard fields like subject lines and sender addresses sit alongside email body text encoded in Base64 (using UTF-16LE formatting).
When a user boots into QuickLook, the application simply reads these flat XML files. If the user composes an email or modifies a task, QuickLook appends those changes back to the XML structure. When Windows boots and Outlook launches next, the plug-in parses those files, generates the queued outgoing messages, and merges updated tasks into the live Exchange profile. Cathode Ray Dude calls this “one of the less disgusting hacks that we've seen in this series.” While offline queuing seems foreign today, it fit the executive landscape of 2010:
> “Quick Look is definitely the dying gasp of a past era it's a fading memory of hot sinking email from your Palm Pilot so you can send it with Eudora but I think it still might have made a whiff of sense at this point.”
---
[15:30](https://www.youtube.com/watch?v=ssob-7sGVWs&t=930s) The Discovery: QuickLook Is an EFI Application
Navigating two directory levels above the XML cache on the `HP_TOOLS` partition reveals the true nature of the QuickLook program itself: it is an `.efi` file. While modern firmware engineers and system enthusiasts are familiar with EFI executables, HP implemented this at a time when most consumer users had never encountered the concept. QuickLook does not run on top of an embedded Linux kernel, nor does it rely on a stripped-down Windows PE environment. It is an application built to run directly on the system's core platform firmware.
Cathode Ray Dude notes that discovering this file demands an explanation of how modern x86 personal computers initialize and boot, because the underlying mechanism represents a complete departure from the historical standard that preceded it for three decades.
---
[16:06](https://www.youtube.com/watch?v=ssob-7sGVWs&t=966s) From Legacy BIOS to UEFI: The Quiet Boot Revolution
To understand what an EFI application is, one must understand that the traditional PC BIOS no longer exists on modern machines:
> “You know the term BIOS yeah those don't exist anymore.”
Starting with the original 1981 IBM PC, the BIOS (Basic Input/Output System) served as the motherboard firmware responsible for bootstrapping the hardware, running initial self-tests, and providing an rudimentary hardware abstraction layer. For the next twenty-five years, that architecture remained fundamentally frozen in time. Even a cutting-edge Core 2 Duo system purchased in 2007 initialized its hardware in roughly the same sequence, using legally distinct but architecturally identical routines, as an IBM machine from 1981 before handing control over to modern 21st-century operating system code.
That paradigm was eventually supplanted by UEFI (Unified Extensible Firmware Interface), a clean-sheet firmware specification that entered consumer personal computers in the late 2000s. The industry engineered this transition to be as invisible as possible: - Motherboard vendors created graphical setup utilities that intentionally mimicked legacy BIOS menus, or hid hardware diagnostic text behind static vendor splash screens. - Compatibility with older operating systems was maintained via the optional CSM (Compatibility Support Module), which emulates traditional BIOS interrupts but is frequently disabled by default on contemporary hardware. - The most overt visual tell for end users was often an aesthetic downgrade: replacement CMOS setup menus morphed from fast, functional text-mode screens into gaudy graphical environments that “looked like the box for a GeForce 4 and was probably much harder to navigate than what you were using before.”
---
[18:52](https://www.youtube.com/watch?v=ssob-7sGVWs&t=1132s) File Systems, GPT, and Motherboard-Executed Binaries
The foundational technical limitation of the legacy PC BIOS was its complete lack of file system awareness. Because an old BIOS had no concept of partitions or file structures, booting required examining raw physical sectors on connected storage media:
> “When you started up your PC in 81 or 2004 the only thing it knew was which mass storage devices were connected and it would try to boot by just looking at each one in turn reading the first sector and seeing if there was bootstrap code there if not then you'd get a message like no bootable devices found and that was it.”
Creating a bootable disk under the legacy model required embedding raw machine code into the Master Boot Record (MBR)—an opaque, brittle procedure. UEFI replaced this entirely by incorporating native, low-level understanding of disk partitioning and file systems. Under UEFI, the firmware reads a GUID Partition Table (GPT), identifies supported file systems (primarily FAT32), and traverses the directory structure directly.
When a modern motherboard powers on, it navigates to `/EFI/BOOT/` to look for `.efi` files: - UEFI `.efi` binaries use the exact same Portable Executable (PE/COFF) container format as standard Windows `.exe` files. - Despite sharing an executable container with Windows programs, the machine code inside targets the UEFI firmware interfaces directly rather than the Win32 subsystem or an operating system kernel. - These binaries are executed natively by the motherboard firmware before any operating system kernel is loaded.
This architectural shift also explains modern boot conveniences, such as selecting named boot options like "Windows Boot Manager" or "Arch Linux" directly in setup instead of guessing between raw hard drive model numbers. While the original 1981 BIOS provided a primitive hardware abstraction layer for serial ports, disks, and basic character displays, it lacked networking, native sound, and modern peripheral protocols. UEFI expanded that concept into a complete pre-boot operating environment capable of executing sophisticated, standalone graphical applications like QuickLook without Windows running at all.
[21:04](https://www.youtube.com/watch?v=ssob-7sGVWs&t=1264s) The Long Tradition of Operating System-Less PC Software
In the earliest days of the PC platform, running software without an underlying operating system was not an insurmountable hurdle. The system BIOS provided built-in routines to communicate with virtually every hardware device expected in a personal computer. Developers could write self-contained software that funneled all input and output through BIOS system calls without ever talking to hardware directly or requiring an operating system like MS-DOS or PC DOS. Some programs—often retroactively labeled "Booter apps"—even bypassed DOS and BIOS abstractions entirely to hit the silicon directly, shipping on self-booting floppy disks. While true Booter applications were relatively rare, PC users interacted with OS-less programs all the time: pressing Delete during a 1998 machine boot loaded a CMOS setup utility contained entirely within the BIOS ROM, and by 2004, computers and storage controllers regularly included built-in firmware-flashing and management tools that ran in bare metal environments.
Modern UEFI continued this tradition of running software without an OS, but vastly expanded the hardware's baseline capabilities. Unlike legacy BIOS, UEFI includes native support for high-resolution video via the Graphics Output Protocol (GOP), mouse input through the Simple Pointer Protocol, USB peripherals, network stacks, storage devices, loadable fonts, and full Unicode text parsing and rendering. Because UEFI can execute stand-alone binaries and directly read filesystems, it blurs the line of what qualifies as an operating system. Cathode Ray Dude reflects on this definitional ambiguity: “Given that the UEFI replaced the BIOS and nobody ever claimed that was an OS, I think we have to conclude that EFI apps are essentially just programs running on bare metal.” Much like the standalone diagnostics common on modern corporate workstations, EFI applications take direct and total control of the hardware without a multitasking kernel sitting beneath them.
- Booter games and utilities bypassed DOS layers completely in the 1980s by booting straight off floppies. - Motherboard CMOS setup screens, storage controller configuration menus, and BIOS flashing utilities are historical examples of OS-less software. - Modern graphical UEFI setup interfaces rely on standard firmware protocols: - **GOP (Graphics Output Protocol)** for drawing display frames and arbitrary resolutions. - **Simple Pointer Protocol** for handling mouse and pointer input. - Native Unicode text parsers and modular font loaders.
---
[24:15](https://www.youtube.com/watch?v=ssob-7sGVWs&t=1455s) QuickLook Under the Hood as an EFI Application
Understanding the nature of EFI binaries demystifies how HP built QuickLook. Pressing the dedicated QuickLook power button triggers customized motherboard firmware hardcoded to traverse the disk, locate a specific file at `HP_TOOLS\QuickLook\QuickLook.efi`, and execute it. In doing so, HP did not merely clone the look of Microsoft Outlook; they produced a custom mail and calendar client entirely decoupled from Windows APIs. Weighing in at roughly three megabytes, the application boots instantaneously because it requires no driver initialization passes, relying solely on services already present in the computer's system memory space.
```mermaid flowchart TD accTitle: HP QuickLook Boot Sequence accDescr: Diagram illustrating how the dedicated button launches the QuickLook EFI app from the FAT32 partition.
subgraph Hardware ["Firmware & Partitioning"] BTN["QuickLook Power Button Pressed"] --> FW["HP Custom UEFI Firmware"] FW -->|"Mounts FAT32 Partition"| PART["HP_TOOLS Volume"] end
subgraph AppExecution ["EFI Application Launch"] PART -->|"Loads binary"| EFI["QuickLook.efi (3 MB Signed Binary)"] EFI -->|"Parses offline cache"| XML["Cached Outlook Data (XML)"] EFI --> GOP["GOP Screen Rendering & Mouse Pointer"] end ```
The design choices behind QuickLook also explain why it depends on a separate Outlook synchronization plugin running inside Windows. In 2010, Windows installations almost universally formatted system drives with NTFS. Although the UEFI specification dictates mandatory FAT32 support, it does not strictly prevent vendors or developers from adding NTFS or ext4 filesystem drivers—as demonstrated by third-party utilities like Rufus—but open-source or commercial NTFS drivers for EFI were not standard in firmware of that vintage. Consequently, the QuickLook binary and its associated cache must reside on a dedicated FAT32 partition labeled `HP_TOOLS`. Aside from the partition label and FAT32 format, there is nothing proprietary about the disk structure; any user can manually recreate it according to HP's published deployment guides.
There is one critical restriction: HP cryptographically signed the `QuickLook.efi` executable. While this prevented Cathode Ray Dude from replacing the launcher with an EFI port of *Doom*, it addresses a glaring security liability. Because the `HP_TOOLS` volume is a standard FAT32 partition accessible from within Windows, any untrusted software running with user privileges could swap the executable. As Cathode Ray Dude observes, “HP has a pretty good argument that the partition is just, you know, there, and any program in Windows could overwrite these files with compromised ones, and then if you booted into QuickLook, they would have total control over your system with literally no way to stop them.”
- The QuickLook binary is located at `HP_TOOLS\QuickLook\QuickLook.efi`. - UEFI natively mandates FAT32 support, requiring HP to store QuickLook on an auxiliary volume separate from the primary NTFS Windows partition. - Similar to modern Linux distribution ISOs (Fedora, Ubuntu) that boot from bare FAT32 USB sticks without specialized write tools like Balena Etcher, UEFI locates bootable binaries through standard directory naming conventions. - Security enforcement requires signed binaries to prevent unprivileged Windows malware from placing malicious, persistent bare-metal payloads into the firmware boot path.
---
[28:13](https://www.youtube.com/watch?v=ssob-7sGVWs&t=1693s) Evaluating QuickLook: Performance Limits and Clean Design
Despite the technical achievement of running an Outlook-style workflow inside system firmware, QuickLook has noticeable operational shortcomings. UEFI protocols are intentionally rudimentary, lacking hardware acceleration frameworks or high-performance graphics pipelines. As a result, screen refreshes in QuickLook feel sluggish, and cursor tracking stutters between 10 and 15 frames per second, mimicking the clunky behavior of graphical motherboard BIOS screens. In the era of solid-state drives, where modern installations of Windows or Linux cold-boot in eight seconds or less, the core rationale of a low-overhead, pre-boot viewing environment has vanished entirely.
Even so, Cathode Ray Dude commends HP for the interface's aesthetic restraint and execution. Unlike messy rapid-boot implementations from competing vendors, QuickLook features sharp typography, well-defined borders, legible black text against white backdrops, and none of the unreadable flat-styling trends that characterized later UI design. Summarizing the effort, Cathode Ray Dude remarks, “It's honestly the least embarrassing thing we've seen in the entire Quick Start series by a long shot.” HP successfully engineered a functional, dignified bare-metal application—setting up a dramatic contrast with the company's next pre-boot endeavor.
- The interface updates at a halting 10 to 15 frames per second due to the lack of hardware acceleration in UEFI GOP rendering. - Modern solid-state drives rendered the fast-boot feature obsolete by allowing complete operating systems to boot in under eight seconds. - The user interface avoided flat design tropes in favor of clean visual framing, consistent borders, readable banners, and crisp typography.
---
[29:50](https://www.youtube.com/watch?v=ssob-7sGVWs&t=1790s) The Nightmare of HP Daystarter
Having produced a remarkably polished tool in QuickLook, HP followed it up with an entirely unhinged pre-boot concept called HP Daystarter. Cathode Ray Dude recalls stumbling across the product description while researching QuickLook documentation: “I saw this on HP's website while looking for QuickLook, and the description made my blood run cold: 'HP Daystarter displays Microsoft Outlook calendar information and custom messages while Windows loads.'”
Rather than offering a distinct alternative boot target or isolated firmware environment, Daystarter attempts to wedge an active Outlook schedule display directly into the Windows startup animation. Cathode Ray Dude reboots the test notebook into a standard Windows boot sequence to demonstrate the tool in real time, capturing how the calendar layout flashes onto the screen during machine startup before abruptly vanishing as soon as the operating system finishes loading its session.
> “QuickLook is the tame feature; it's now time to look at Daystarter: a crime against humanity.” — Cathode Ray Dude
[30:42](https://www.youtube.com/watch?v=ssob-7sGVWs&t=1842s) The Illusion of a Simple Boot Splash Hack
Looking closely at a frame grab of the Daystarter screen, the machine displays a full-screen image of an Outlook calendar. The immediate and intuitive assumption is that HP simply used the venerable trick of replacing the Windows boot splash. Replacing the graphic Windows displays during startup has been practiced for decades—Cathode Ray Dude notes that he first swapped out splash screens on Windows 95 when he was nine years old. Historically, Windows loaded an image file from the disk, and replacing that file with a custom image was even Microsoft’s official recommendation for OEM branding until UEFI provided firmware-level image tables.
The Outlook plugin for Daystarter seems to reinforce this theory: it features a configuration section where users choose how much data to capture and when to start. Clicking OK prompts a snapshot capture. If this were a traditional boot splash hack, the software would convert the calendar into a 256-color bitmap and drop it into the Windows folder to overwrite the default Windows 7 boot splash.
```mermaid flowchart TD accTitle: Expected vs Actual Daystarter Architecture accDescr: Diagram contrasting the expected Windows boot splash replacement with HP's actual implementation saving JPEGs to the HP_TOOLS partition.
subgraph Expected["Expected Approach (Boot Splash Hack)"] A["Outlook Plugin"] -->|"Export bitmap"| B["Windows Folder"] B -->|"Windows Kernel loads"| C["Standard Boot Splash"] end
subgraph Actual["Actual HP Implementation"] D["Outlook Plugin"] -->|"Render calendar"| E["HP_TOOLS Partition\n(/DayStarter/*.jpg)"] E -->|"Intercept boot sequence"| F["Custom Pre-OS / SMM Viewer\n(Pauses boot, accepts F-keys)"] end ```
That, however, is not what HP is doing at all. Instead of generating a single system bitmap, the plugin renders the calendar as a collection of JPEGs directly onto the dedicated `HP_TOOLS` partition inside a folder named `DayStarter`. Windows does not read arbitrary JPEG files from an external utility partition during its early boot phase. More alarmingly, the upper-right corner of the screen displays function key prompts, proving the screen accepts interactive user input in the middle of boot.
Pressing F4 actively pauses the Windows boot process in its tracks, allowing the user to examine their schedule. The interface is even designed to let users flip between multiple days of calendar entries using the arrow keys, though in testing, pressing arrow keys caused the screen to blank and boot to resume. Cathode Ray Dude warns: “If you don’t have a pit in your stomach right now, it’s cuz you don’t know the technical horror on display here.”
---
[32:27](https://www.youtube.com/watch?v=ssob-7sGVWs&t=1947s) The Deterministic Reality of the Boot Process
To understand why this behavior is so shocking, one has to examine the fundamental architecture of personal computers. Modern operating systems give the impression of effortless multitasking, but Cathode Ray Dude explains that true simultaneity on a CPU is an illusion:
> “Your computer is a heavily dressed up version of a Turing machine, a theoretical model for computing in which you have a machine that can do nothing other than look at a strip of tape containing instructions, move forward and backwards along that tape, and then based on the instruction in each cell, it can either write a new value to that cell or halt processing.”
When a system powers on, the CPU is hardwired to jump to a specific memory address and execute whatever code resides there—historically the BIOS, and today the UEFI firmware. The firmware performs basic power-on self-tests, locates a bootable drive, and hands control over to the OS bootloader, which loads the Windows kernel. At this critical juncture, a modern 64-bit multicore processor with hyperthreading behaves essentially like a MOS 6502 from 1979: a deterministic machine executing instructions strictly sequentially off a metaphorical tape.
```mermaid flowchart LR accTitle: Linear CPU Boot Flow accDescr: Sequence diagram illustrating the deterministic handoff from hardware reset to BIOS/UEFI, bootloader, and Windows Kernel.
A["CPU Reset"] --> B["Firmware / UEFI"] B --> C["Storage Boot Code"] C --> D["Windows Kernel Execution"] D --> E["Absolute Kernel Hardware Control"] ```
Once the Windows kernel begins running, it claims absolute, unilateral authority over the machine. Every instruction pointer advance or jump is dictated entirely by Microsoft's code. There are no architectural gaps into which third-party software can inject itself. “Asking a question like how do we run our own program while the kernel is booting is like asking how do I push my hand through this brick wall,” Cathode Ray Dude argues.
Even if an OEM wrote a custom kernel driver to stomp over the display frame buffer, the driver would either crash the system or fail to execute frequently enough to prevent the kernel's native boot-splash code from overwriting it. Nothing is permitted preemptive control over the CPU during this phase of initialization. In practical PC architecture terms, intercepting the boot sequence, rendering JPEGs, and pausing execution for user keyboard input is structurally impossible.
- Alan Turing’s 1936 theoretical machine model remains the foundation of how x86 CPUs consume boot instructions. - Early boot code that renders the Windows animated startup logo is among the lowest-level, most rigid code in the OS. - Under standard operating system constraints, third-party software cannot preempt the kernel before it has initialized core subsystems.
---
[36:24](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2184s) The Horrifying Truth: System Management Mode
Because directly intercepting the Windows boot sequence is impossible by normal means, one might wonder if HP simply hacked Windows system files. However, modifying core files directly is stopped cold by Windows Resource Protection (WRP), which aggressively detects altered system files and restores clean originals. Furthermore, patching system binaries would break every time Microsoft released an OS update, forcing HP into an unsustainable update cycle.
```mermaid flowchart TD accTitle: System Management Mode Ring Hierarchy accDescr: Hierarchy of CPU privilege levels showing User Mode Ring 3, Kernel Ring 0, and the hidden Ring -2 System Management Mode.
subgraph StandardPrivilege["Standard x86 Privilege Levels"] R3["Ring 3: Applications\n(User Mode)"] R0["Ring 0: Operating System Kernel\n(Total OS Authority, Scheduler)"] R3 -->|"Supervised by"| R0 end
subgraph DarkPrivilege["Hidden Hardware Privilege"] SMM["Ring -2: System Management Mode (SMM)\n(Firmware execution, SMI interrupts, preempts Kernel)"] end
SMM -.->|"Completely freezes & preempts"| R0 ```
With file tampering ruled out, HP turned to a mechanism far deeper and more dangerous: System Management Mode (SMM). Cathode Ray Dude reveals that HP placed Daystarter directly into SMM, an architectural feature sometimes colloquially referred to as "Ring -2." Intel originally introduced SMM with the 386SL processor to handle notebook power management transparently.
In standard x86 protected mode, execution privilege is split into rings: - **Ring 3**: Where standard user-space applications live. - **Ring 0**: Where the operating system kernel operates with absolute authority.
Under Ring 0, the kernel scheduler holds total sovereignty over CPU time. If an application attempts unauthorized memory access or hogs cycles, Ring 0 terminates or freezes it. While the kernel can mask standard device hardware interrupts, it cannot mask a Non-Maskable Interrupt (NMI). Yet even NMIs proved insufficient for the complex power orchestration Intel envisioned for battery-powered laptops.
Intel needed a way to dynamically spin down idle hardware—such as spinning down a mechanical hard drive after a period of inactivity—and automatically spin it back up the moment a program requested disk access. Because existing operating systems and software knew nothing about laptop power-saving states, this management had to be completely transparent. When an access occurred, the hardware had to pause everything, wake the peripheral, restore the controller state, and resume execution without the application or operating system ever realizing it had been suspended. This required an execution state that could preempt and freeze even the Ring 0 operating system kernel itself without warning or recourse.
[40:26](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2426s) SMM: The "Star Chamber" of Privilege
System Management Mode (SMM) was created by Intel out of necessity: if an operating system crashed or locked up at a critical hardware juncture, catastrophic hardware damage could occur. SMM was engineered to be more privileged than the OS kernel and higher priority than a Non-Maskable Interrupt (NMI). In computer architecture, it occupies an execution realm often termed "Ring -2." As Cathode Ray Dude frames it:
> “To put it simply, code running in the SMM is more powerful than God.”
SMM holds absolute authority to interrupt execution at any time, overrides all system behavior, ignores NMIs, and cannot be monitored or disabled by the operating system. Because it acts as an uninspected, undetectable "Star Chamber" wielding unchecked control, it poses a profound architectural security risk. Intel eventually introduced even deeper privilege layers, like Active Management Technology (AMT)—often labeled "Ring -3"—which are even less auditable. Should malicious actors slip code into these root-level modes, total compromise follows.
```mermaid flowchart TD accTitle: x86 Privilege Hierarchy and SMM accDescr: Diagram illustrating privilege rings from user mode down to Ring minus 3.
subgraph UserOS["Operating System Domain"] R3["Ring 3: User Space (Applications)"] R0["Ring 0: Kernel Space (OS Drivers / Core)"] end
subgraph FirmwareHardware["Firmware & Hardware Execution Levels"] Rneg1["Ring -1: Hypervisor (Virtualization)"] Rneg2["Ring -2: System Management Mode (SMM)"] Rneg3["Ring -3: Management Engine (Intel AMT)"] end
R3 --> R0 R0 --> Rneg1 Rneg1 --> Rneg2 Rneg2 --> Rneg3 ```
[41:28](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2488s) Deconstructing the DayStarter SMM Exploit
A surviving slide from an internal HP presentation indicates that the laptop's firmware embeds dedicated SMM code designed to detect when supported versions of Windows are booting, hijacking the display frame buffer until initialization completes. While official documentation is sparse, the technical implementation details can be deduced logically from PC architecture. Because Windows 7 lacks native, complete UEFI support on this hardware, it runs through the Compatibility Support Module (CSM). This configuration leaves UEFI active underneath, granting the SMM payload full access to UEFI subsystem capabilities, including the FAT32 filesystem driver, along with unfettered read/write authority across the entire system memory space.
To hijack the display, DayStarter's SMM routine executes at boot and scans memory using fragile heuristics. A programmer likely sat with a low-level debugger to map out which exact sentinel memory values correlate with the Windows boot splash appearing and disappearing. Once these trigger bytes appear, the SMM routine hooks the UEFI Graphics Output Protocol (GOP) driver or the emulated VESA BIOS routines. Every time Windows 7 tries to draw an update, execution redirects into the DayStarter routine instead. The hack checks for user keystrokes, swaps between stored JPEG slides if requested, and overwrites the frame buffer with its custom display output. When the memory scan determines that Windows has finished loading, the code ideally unhooks the video routines and unloads itself from SMM. If the user presses the "pause" key, the routine presumably traps the CPU in an endless tight loop, choking the OS kernel of processor cycles until execution resumes.
```mermaid flowchart TD accTitle: DayStarter SMM Interception Flow accDescr: Step-by-step flowchart of the DayStarter SMM boot heuristic and frame buffer hijack.
subgraph Detection["Boot Monitoring"] A["Machine boots via CSM"] --> B["SMM routine executes"] B --> C["Sniff system memory for Windows boot splash heuristics"] end
subgraph Interception["Display Hijack"] C -->|"Sentinel values detected"| D["Hook UEFI GOP / VESA BIOS routines"] D --> E["Intercept Windows frame buffer writes"] E --> F["Read JPEG from FAT32 via UEFI drivers"] F --> G["Blit calendar/battery image to display"] end
subgraph Exit["Handoff to OS"] G --> H{"OS load complete?"} H -->|"No / Key pressed"| I["Loop or swap slide; choke kernel on pause"] I --> G H -->|"Yes"| J["Unhook video routines & purge from SMM"] J --> K["Hand clear frame buffer to Windows desktop"] end ```
[43:17](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2597s) Fragility, Negligence, and the Pointlessness of DayStarter
Cathode Ray Dude strongly condemns DayStarter as an irresponsible and grotesque misuse of critical low-level hardware registers. Historically, SMM has avoided corporate bloatware abuses, with legacy BIOS-era USB keyboard emulation being one of the few historical exceptions to its strictly low-level role. Pushing consumer-facing application logic into SMM risks severe system instability. Because the entire frame buffer takeover depends on arbitrary heuristic sentinel values, any regular Windows patch from Microsoft altering memory layouts could have permanently broken the logic, causing the SMM code to hold the screen hostage indefinitely and strand users on an unbootable black screen or frozen image.
> “DayStarter is a horrifying abuse of a hardware feature that shouldn't exist, certainly wasn't intended for this, and should never have been used for something so trivial.”
The enormous engineering risk yields negligible practical value. At best, the software gives a business user a roughly ten-second glance at a calendar image before the OS loads—a window so short that a user must pause the boot to read it, rendering the fast boot irrelevant when they could simply wait for the desktop to load Microsoft Outlook. If fast loading was the goal, HP could have bundled a lightweight, 256-kilobyte startup application in user space to display the exact same cached JPEGs immediately upon reaching the desktop, entirely avoiding firmware-level tampering.
[44:32](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2672s) The Cynical Thesis: Consumer Tech Saturation and the "Jellybean" Machine
Why would an enterprise OEM invest significant engineering resources into something so reckless? The speaker considers an innocent hypothesis—an engineer playing with newfound UEFI capabilities without considering safety, which upper management approved without scrutiny—before dismissing it as improbable within a bureaucratic corporate giant like HP. Instead, he presents a broader cultural thesis: modern consumer technology is an era that has largely drawn to a close, with all foundational, life-altering products (like the Sony Walkman or vacuum cleaners) already solved decades ago.
> “The great inventions are invented, and an overwhelming proportion of problems, as far as consumer products go, are solved.”
When a consumer product reaches physical and technological perfection, classical market capitalism struggles to find legitimate vectors for growth. Once everyone owns a vacuum cleaner that functions reliably, manufacturers resort to superficial iterations or convoluted redesigns that often degrade overall product quality. Personal computer OEMs face an even more extreme crisis because they do not manufacture the functional components inside their hardware: - The internal components are commodity "jellybean" parts shared across the entire industry: Intel CPUs and chipsets, Western Digital hard drives, Realtek audio chips, Nvidia graphics cards, and standard rectangular LCD panels. - Screen differentiation is purely an exercise in choosing an objectively better or worse commodity panel (such as choosing a standard 1366×768 panel over a superior resolution), rather than proprietary innovation. - The only bespoke elements an OEM contributes are the external plastic trim, sheet metal chassis, and printed circuit board traces routing identical signals between the same commodity parts. - Motherboard firmware is fundamentally constrained because it must boot standardized operating systems, leading manufacturers to express differentiation through superficial gimmicks, like stylized CMOS setup menus and absurd, firmware-level feature add-ons like DayStarter.
[49:56](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2996s) The Commoditization Trap and the Fable of Executive Features
Laptops offer rare opportunities for hardware distinctiveness compared to desktop motherboards—such as the HP EliteBook line's pop-out keyboard LED. Yet even that feature highlights how little genuine territory hardware makers have left: it is merely a commodity white LED borrowed from an idea IBM already shipped on ThinkPads back in 1999. Beyond standard peripherals like keyboards, mice, speakers, and monitors, nearly every accessory someone could want is already sold over USB or Thunderbolt. The fundamental challenges of personal computing have been reduced to minor conveniences, like port counts and connector placement.
Cathode Ray Dude illustrates the institutional panic of the late 2000s through a satirical narrative of an executive meeting at HP:
```mermaid flowchart TD accTitle: The Corporate Logic of Quick Start Features accDescr: Flow diagram showing how executive bonus structures and commoditized hardware force engineers into bizarre firmware hacks.
subgraph Corporate Pressure VP["VP 'Bob' Demands Differentiation<br/>'Sell $2,500 notebooks with unique executive features!'"] Reality["Engineer Reality Check:<br/>'We sell invisible plinths whose sole purpose is to hold up Microsoft Office.'"] Panic["Bob Threatens Firings<br/>Engineers scramble in a panic"] end
subgraph The Firmware Hack Question["What do executives do?<br/>They run Microsoft Outlook."] Constraint["Microsoft controls Windows and Outlook.<br/>HP can't touch them."] Solution["Touch the only domain HP owns:<br/>Pre-boot UEFI firmware execution."] end
VP --> Reality Reality --> Panic Panic --> Question Question --> Constraint Constraint --> Solution ```
As Cathode Ray Dude frames the exchange: “Our business is selling invisible, unnoticeable plinths whose sole purpose is to hold up a copy of Microsoft Office and that's the truth.” But middle managers—personified by a fictional VP named "Bob"—need visible wins for their bonuses. Corporate executives run Outlook on Core 2 Duo processors with 4 GB of RAM, and throwing faster CPUs or GPUs at them solves no actual workplace problem. Because HP cannot alter Windows or Outlook directly, the only territory left under their direct engineering domain is the pre-boot firmware environment before Windows loads. Under pressure to make email load faster, HP engineers wrote a bare-metal EFI application that executes directly on the bare CPU just to save an executive ten seconds of boot time—an engineering absurdity that users would inevitably bypass anyway.
[53:31](https://www.youtube.com/watch?v=ssob-7sGVWs&t=3211s) Industrial Stagnation, Duplicated Labor, and Market Saturation
Once HP delivered an EFI Outlook clone that boots in eight seconds, middle management immediately needed another milestone. Because firmware cannot speed up the actual Windows boot sequence, the logical leap was to force code execution *during* boot—resulting in the Daystarter display hack. This bizarre engineering occurs because the personal computer industry has effectively finished its core mission. Cathode Ray Dude compares PC makers to automotive giants like Hyundai, Dodge, Honda, and Toyota: legions of skilled engineers perform real, difficult work, but they solve identical problems to identical standards because the underlying recipes for engines, frames, and upholstery are already solved.
Cathode Ray Dude argues that bureaucratic self-preservation keeps this cycle spinning: “Middle management has a vested interest in keeping things unsolved because individuals profit from creating chaos which can then be made to look like progress.” PC hardware has outpaced human utility to the point where modern upgrades feel like dropping 600-horsepower engines into golf carts. A solid-state drive and PC from 2016 still perform everyday consumer tasks just as well as modern machines. Surplus computers of sufficient quality sit in landfills solely because economic models make distribution unprofitable, while manufacturers continually flail about to invent synthetic reasons for consumer upgrades.
- **Duplicated engineering effort**: PC vendors all assemble the same standard commodity parts ("jelly beans") into motherboard trays, creating an illusion of competitive choice where meaningful competition is virtually impossible. - **Silicon saturation**: Chipmakers and OEMs have saturated the market many times over, rendering incremental performance boosts largely unnoticeable to typical users. - **Durable hardware longevity**: Mainstream computing tasks—web browsing, document editing, email—have seen diminishing real-world gains from hardware improvements since the mid-2010s.
[56:42](https://www.youtube.com/watch?v=ssob-7sGVWs&t=3402s) Chronology Realization, Architectural Irony, and Outro
While this brand of desperate product engineering feels emblematic of late-era PC stagnation, Cathode Ray Dude admits an ironic timing discovery late in his research: HP QuickLook originated around 2007. The year 2010 was an era of genuine architectural transition—marked by the broad migration to PCI Express, the introduction of USB 3.0, and the shift toward UEFI—making HP's pre-boot hacks seem uncharacteristically desperate for that exact moment. However, conceived during the late Core 2 Duo doldrums of 2007, an instant-on pre-boot inbox made far more strategic sense, surviving into the 2010 product catalog purely on corporate inertia.
Reflecting on the sheer scale of the engineering involved, Cathode Ray Dude emphasizes the staggering mismatch between effort and outcome: “The actual features here are laughably simple compared to the Titanic effort put in to make them possible.” Developing standalone, bare-metal UEFI applications and patching boot sequences just to display an un-synced calendar was a gargantuan technical undertaking to achieve an outcome already rendered obsolete by the arrival of devices like the iPhone 4 in that very same year.
Wrapping up the episode, he humorously characterizes his breakdown as an hour-long "TED Talk" on the systemic absurdities of modern society and computing, thanking his Patreon supporters for funding his full-time work rescuing bizarre, forgotten technology from scrap heaps to dissect its hidden secrets.
## Notable quotes > [43:17](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2597s) DayStarter is a horrifying abuse of a hardware feature that shouldn't exist, certainly wasn't intended for this, and should never have been used for something so trivial. — Cathode Ray Dude
> [53:31](https://www.youtube.com/watch?v=ssob-7sGVWs&t=3211s) Middle management has a vested interest in keeping things unsolved because individuals profit from creating chaos which can then be made to look like progress. — Cathode Ray Dude
> [44:32](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2672s) The great inventions are invented, and an overwhelming proportion of problems, as far as consumer products go, are solved. — Cathode Ray Dude
> [40:26](https://www.youtube.com/watch?v=ssob-7sGVWs&t=2426s) To put it simply, code running in the SMM is more powerful than God. — Cathode Ray Dude
> [21:04](https://www.youtube.com/watch?v=ssob-7sGVWs&t=1264s) Given that the UEFI replaced the BIOS and nobody ever claimed that was an OS, I think we have to conclude that EFI apps are essentially just programs running on bare metal. — Cathode Ray Dude
## Mentioned HP, HP EliteBook 8440p, QuickWeb, Splashtop OS, Windows 7, QuickLook, Microsoft Outlook, Oracle, Microsoft Exchange, Outlook 2003, Outlook 2007, Palm Pilot, Eudora, IBM PC, Core 2 Duo, UEFI, BIOS, CSM, GeForce 4, Rufus, Doom, Balena Etcher, HP Daystarter, Windows 95, Intel, Intel 386SL, Active Management Technology, Sony Walkman, Western Digital, Realtek, Nvidia, IBM ThinkPad, Hyundai, Dodge, Honda, Toyota, iPhone 4, Cathode Ray Dude, Patreon
## Video description HP took a look at all the other Quick Start products and said "oh, we can do worse." They did.
Support me on Patreon: https://www.patreon.com/cathoderaydude Tip me: https://ko-fi.com/cathoderaydude
Chapters: 00:00 Quickweb recap 04:02 Feature 1: QuickLook 09:15 QuickLook under the hood 15:30 What's an EFI application? 29:15 QuickLook in summary 29:50 Feature 2: Daystarter 32:27 Daystarter: A Horror Story 44:32 But why, though? 58:03 Outro
[Source](https://www.youtube.com/watch?v=ssob-7sGVWs)