diff --git a/Makefile b/Makefile
index a4fcf0c..bf81490 100644
--- a/Makefile
+++ b/Makefile
@@ -11,8 +11,7 @@
 EFI_AR		:= $(EFI_TOOLCHAIN)ar
 
 EFI_PATH	:= third_party/gnu-efi
-EFI_LIB_PATHS	:= $(EFI_PATH)/$(ARCH)/lib $(EFI_PATH)/$(ARCH)/gnuefi out
-EFI_INC_PATHS	:= $(EFI_PATH)/inc $(EFI_PATH)/inc/$(ARCH) $(EFI_PATH)/inc/protocol
+EFI_LIB_PATHS	:= $(EFI_PATH)/$(ARCH)/gnuefi out
 
 EFI_CRT0	:= $(EFI_PATH)/$(ARCH)/gnuefi/crt0-efi-$(ARCH).o
 EFI_LINKSCRIPT	:= $(EFI_PATH)/gnuefi/elf_$(ARCH)_efi.lds
@@ -20,16 +19,15 @@
 EFI_CFLAGS	:= -fpic -fshort-wchar -fno-stack-protector -mno-red-zone
 EFI_CFLAGS	+= -Wall
 EFI_CFLAGS	+= -std=c99
-EFI_CFLAGS	+= -ffreestanding -nostdinc -Iinclude -Isrc -Ithird_party/edk2 -Ithird_party/lk/include
+EFI_CFLAGS	+= -ffreestanding -nostdinc -Iinclude -Isrc -Ithird_party/lk/include
 EFI_CFLAGS	+= $(patsubst %,-I%,$(EFI_INC_PATHS))
-EFI_CFLAGS	+= -DHAVE_USE_MS_ABI=1
 EFI_CFLAGS	+= -ggdb
 
 EFI_LDFLAGS	:= -nostdlib -znocombreloc -T $(EFI_LINKSCRIPT)
 EFI_LDFLAGS	+= -shared -Bsymbolic
 EFI_LDFLAGS	+= $(patsubst %,-L%,$(EFI_LIB_PATHS))
 
-EFI_LIBS	:= -lutils -lefi -lgnuefi
+EFI_LIBS	:= -lutils -lgnuefi
 
 what_to_build::	all
 
@@ -58,6 +56,7 @@
 endif
 
 LIB_SRCS := \
+    lib/efi/guids.c \
     lib/utils.c \
     lib/loadfile.c \
     lib/console-printf.c \
diff --git a/include/efi/boot-services.h b/include/efi/boot-services.h
new file mode 100644
index 0000000..3ee9ec5
--- /dev/null
+++ b/include/efi/boot-services.h
@@ -0,0 +1,204 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+#include <efi/protocol/device-path.h>
+
+#define EFI_BOOT_SERVICES_SIGNATURE 0x56524553544f4f42
+#define EFI_BOOT_SERVICES_REVISION EFI_SPECIFICATION_VERSION
+
+typedef size_t efi_tpl;
+
+#define TPL_APPLICATION 4
+#define TPL_CALLBACK    8
+#define TPL_NOTIFY     16
+#define TPL_HIGH_LEVEL 31
+
+typedef enum {
+    AllocateAnyPages,
+    AllocateMaxAddress,
+    AllocateAddress,
+    MaxAllocateType
+} efi_allocate_type;
+
+typedef struct {
+    uint32_t Type;
+    efi_physical_addr PhysicalStart;
+    efi_virtual_addr VirtualStart;
+    uint64_t NumberOfPages;
+    uint64_t Attribute;
+} efi_memory_descriptor;
+
+#define EFI_MEMORY_UC 0x0000000000000001
+#define EFI_MEMORY_WC 0x0000000000000002
+#define EFI_MEMORY_WT 0x0000000000000004
+#define EFI_MEMORY_WB 0x0000000000000008
+#define EFI_MEMORY_UCE 0x0000000000000010
+#define EFI_MEMORY_WP 0x0000000000001000
+#define EFI_MEMORY_RP 0x0000000000002000
+#define EFI_MEMORY_XP 0x0000000000004000
+#define EFI_MEMORY_NV 0x0000000000008000
+#define EFI_MEMORY_MORE_RELIABLE 0x0000000000010000
+#define EFI_MEMORY_RO 0x0000000000020000
+#define EFI_MEMORY_RUNTIME 0x8000000000000000
+
+#define EFI_MEMORY_DESCRIPTOR_VERSION 1
+
+typedef enum {
+    EFI_NATIVE_INTERFACE
+} efi_interface_type;
+
+typedef enum {
+    AllHandles,
+    ByRegisterNotify,
+    ByProtocol
+} efi_locate_search_type;
+
+#define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL  0x00000001
+#define EFI_OPEN_PROTOCOL_GET_PROTOCOL        0x00000002
+#define EFI_OPEN_PROTOCOL_TEST_PROTOCOL       0x00000004
+#define EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 0x00000008
+#define EFI_OPEN_PROTOCOL_BY_DRIVER           0x00000010
+#define EFI_OPEN_PROTOCOL_EXCLUSIVE           0x00000020
+
+typedef struct {
+    efi_handle agent_handle;
+    efi_handle controller_handle;
+    uint32_t attributes;
+    uint32_t open_count;
+} efi_open_protocol_information_entry;
+
+#define EFI_HII_PACKAGE_LIST_PROTOCOL_GUID \
+    {0x6a1ee763, 0xd47a, 0x43b4, {0xaa, 0xbe, 0xef, 0x1d, 0xe2, 0xab, 0x56, 0xfc}}
+
+typedef struct efi_hii_package_list_header efi_hii_package_list_header;
+typedef efi_hii_package_list_header* efi_hii_package_list_protocol;
+
+// fwd declare efi_system_table to break circular dependencies
+typedef struct efi_system_table efi_system_table;
+typedef efi_status (*efi_image_entry_point) (efi_handle img, efi_system_table* sys) EFIAPI;
+
+typedef struct {
+    efi_table_header Hdr;
+
+    efi_tpl (*RaiseTPL) (efi_tpl new_tpl) EFIAPI;
+
+    void (*RestoreTPL) (efi_tpl old_tpl) EFIAPI;
+
+    efi_status (*AllocatePages) (efi_allocate_type type, efi_memory_type memory_type,
+                                 size_t pages, efi_physical_addr* memory) EFIAPI;
+
+    efi_status (*FreePages) (efi_physical_addr memory, size_t pages) EFIAPI;
+
+    efi_status (*GetMemoryMap) (size_t* memory_map_size, efi_memory_descriptor* memory_map,
+                                size_t* map_key, size_t* desc_size, uint32_t* desc_version) EFIAPI;
+
+    efi_status (*AllocatePool) (efi_memory_type pool_type, size_t size, void** buf) EFIAPI;
+
+    efi_status (*FreePool) (void* buf) EFIAPI;
+
+    efi_status (*CreateEvent) (uint32_t type, efi_tpl notify_tpl,
+                               efi_event_notify notify_fn, void* notify_ctx,
+                               efi_event* event) EFIAPI;
+
+    efi_status (*SetTimer) (efi_event event, efi_timer_delay type, uint64_t trigger_time) EFIAPI;
+
+    efi_status (*WaitForEvent) (size_t num_events, efi_event* event, size_t* index) EFIAPI;
+
+    efi_status (*SignalEvent) (efi_event event) EFIAPI;
+
+    efi_status (*CloseEvent) (efi_event event) EFIAPI;
+
+    efi_status (*CheckEvent) (efi_event event) EFIAPI;
+
+    efi_status (*InstallProtocolInterface) (efi_handle* handle, efi_guid* protocol,
+                                            efi_interface_type intf_type, void* intf) EFIAPI;
+
+    efi_status (*ReinstallProtocolInterface) (efi_handle hadle, efi_guid* protocol,
+                                              void* old_intf, void* new_intf) EFIAPI;
+
+    efi_status (*UninstallProtocolInterface) (efi_handle handle, efi_guid* protocol,
+                                              void* intf) EFIAPI;
+
+    efi_status (*HandleProtocol) (efi_handle handle, efi_guid* protocol, void** intf) EFIAPI;
+
+    void* Reserved;
+
+    efi_status (*RegisterProtocolNotify) (efi_guid* protocol, efi_event event,
+                                          void** registration) EFIAPI;
+
+    efi_status (*LocateHandle) (efi_locate_search_type search_type, efi_guid* protocol,
+                                void* search_key, size_t* buf_size, efi_handle* buf) EFIAPI;
+
+    efi_status (*LocateDevicePath) (efi_guid* protocol, efi_device_path_protocol** path,
+                                    efi_handle* device) EFIAPI;
+
+    efi_status (*InstallConfigurationTable) (efi_guid* guid, void* table) EFIAPI;
+
+    efi_status (*LoadImage) (bool boot_policy, efi_handle parent_image_handle,
+                             efi_device_path_protocol* path, void* src, size_t src_size,
+                             efi_handle* image_handle) EFIAPI;
+
+    efi_status (*StartImage) (efi_handle image_handle, size_t* exit_data_size,
+                              char16_t** exit_data) EFIAPI;
+
+    efi_status (*Exit) (efi_handle image_handle, efi_status exit_status,
+                        size_t exit_data_size, char16_t* exit_data) EFIAPI;
+
+    efi_status (*UnloadImage) (efi_handle image_handle) EFIAPI;
+
+    efi_status (*ExitBootServices) (efi_handle image_handle, size_t map_key) EFIAPI;
+
+    efi_status (*GetNextMonotonicCount) (uint64_t* count) EFIAPI;
+
+    efi_status (*Stall) (size_t microseconds) EFIAPI;
+
+    efi_status (*SetWatchdogTimer) (size_t timeout, uint64_t watchdog_code,
+                                    size_t data_size, char16_t* watchdog_data) EFIAPI;
+
+    efi_status (*ConnectController) (efi_handle controller_handle,
+                                     efi_handle* driver_image_handle,
+                                     efi_device_path_protocol* remaining_path,
+                                     bool recursive) EFIAPI;
+
+    efi_status (*DisconnectController) (efi_handle controller_handle,
+                                        efi_handle driver_image_handle,
+                                        efi_handle child_handle) EFIAPI;
+
+    efi_status (*OpenProtocol) (efi_handle handle, efi_guid* protocol, void** intf,
+                                efi_handle agent_handle, efi_handle controller_handle,
+                                uint32_t attributes) EFIAPI;
+
+    efi_status (*CloseProtocol) (efi_handle handle, efi_guid* protocol,
+                                 efi_handle agent_handle, efi_handle controller_handle) EFIAPI;
+
+    efi_status (*OpenProtocolInformation) (efi_handle handle, efi_guid* protocol,
+                                           efi_open_protocol_information_entry** entry_buf,
+                                           size_t* entry_count) EFIAPI;
+
+    efi_status (*ProtocolsPerHandle) (efi_handle handle, efi_guid*** protocol_buf,
+                                      size_t* protocol_buf_count) EFIAPI;
+
+    efi_status (*LocateHandleBuffer) (efi_locate_search_type search_type,
+                                      efi_guid* protocol, void* search_key,
+                                      size_t* num_handles, efi_handle** buf) EFIAPI;
+
+    efi_status (*LocateProtocol) (efi_guid* protocol, void* registration, void** intf) EFIAPI;
+
+    efi_status (*InstallMultipleProtocolInterfaces) (efi_handle* handle, ...) EFIAPI;
+
+    efi_status (*UninstallMultipleProtocolInterfaces) (efi_handle handle, ...) EFIAPI;
+
+    efi_status (*CalculateCrc32) (void* data, size_t len, uint32_t* crc32) EFIAPI;
+
+    void (*CopyMem) (void* dest, void* src, size_t len) EFIAPI;
+
+    void (*SetMem) (void* buf, size_t len, uint8_t val) EFIAPI;
+
+    efi_status (*CreateEventEx) (uint32_t type, efi_tpl notify_tpl,
+                                 efi_event_notify notify_fn, const void* notify_ctx,
+                                 const efi_guid* event_group, efi_event* event) EFIAPI;
+} efi_boot_services;
diff --git a/include/efi/protocol/device-path-to-text.h b/include/efi/protocol/device-path-to-text.h
new file mode 100644
index 0000000..a19e2ab
--- /dev/null
+++ b/include/efi/protocol/device-path-to-text.h
@@ -0,0 +1,20 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+#include <efi/protocol/device-path.h>
+
+#define EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID \
+    {0x8b843e20, 0x8132, 0x4852, {0x90, 0xcc, 0x55, 0x1a, 0x4e, 0x4a, 0x7f, 0x1c}}
+extern efi_guid DevicePathToTextProtocol;
+
+typedef struct efi_device_path_to_text_protocol {
+    char16_t* (*ConvertDeviceNodeToText) (const efi_device_path_protocol* dev_node,
+                                          bool display_only, bool allow_shortcuts) EFIAPI;
+
+    char16_t* (*ConvertDevicePathToText) (const efi_device_path_protocol* dev_path,
+                                          bool display_only, bool allow_shortcuts) EFIAPI;
+} efi_device_path_to_text_protocol;
diff --git a/include/efi/protocol/device-path.h b/include/efi/protocol/device-path.h
new file mode 100644
index 0000000..8356c28
--- /dev/null
+++ b/include/efi/protocol/device-path.h
@@ -0,0 +1,45 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+
+#define EFI_DEVICE_PATH_PROTOCOL_GUID \
+    {0x09576e91, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}
+extern efi_guid DevicePathProtocol;
+
+typedef struct efi_device_path_protocol {
+    uint8_t Type;
+    uint8_t SubType;
+    uint8_t Length[2];
+} efi_device_path_protocol;
+
+#define DEVICE_PATH_HARDWARE       0x01
+#define DEVICE_PATH_ACPI           0x02
+#define DEVICE_PATH_MESSAGING      0x03
+#define DEVICE_PATH_MEDIA          0x04
+#define DEVICE_PATH_BIOS_BOOT_SPEC 0x05
+#define DEVICE_PATH_END            0x7f
+
+#define DEVICE_PATH_INSTANCE_END 0x01
+#define DEVICE_PATH_ENTIRE_END   0xff
+
+#define DEVICE_PATH_HW_PCI        0x01
+#define DEVICE_PATH_HW_PCCARD     0x02
+#define DEVICE_PATH_HW_MEMMAP     0x03
+#define DEVICE_PATH_HW_VENDOR     0x04
+#define DEVICE_PATH_HW_CONTROLLER 0x05
+#define DEVICE_PATH_HW_BMC        0x06
+
+// TODO: sub-types for other types (ACPI, etc)
+
+// TODO: move this to another header? would break circular dependencies between
+// boot-services.h and this header, for efi_memory_type
+typedef struct {
+    efi_device_path_protocol Header;
+    efi_memory_type MemoryType;
+    efi_physical_addr StartAddress;
+    efi_physical_addr EndAddress;
+} efi_device_path_hw_memmap;
diff --git a/include/efi/protocol/driver-binding.h b/include/efi/protocol/driver-binding.h
new file mode 100644
index 0000000..bd928ac
--- /dev/null
+++ b/include/efi/protocol/driver-binding.h
@@ -0,0 +1,30 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+#include <efi/protocol/device-path.h>
+
+#define EFI_DRIVER_BINDING_PROTOCOL_GUID \
+    {0x18a031ab, 0xb443, 0x4d1a, {0xa5, 0xc0, 0x0c, 0x09, 0x26, 0x1e, 0x9f, 0x71}}
+extern efi_guid DriverBindingProtocol;
+
+typedef struct efi_driver_binding_protocol {
+    efi_status (*Supported) (struct efi_driver_binding_protocol* self,
+                             efi_handle controller_handle,
+                             efi_device_path_protocol* remaining_path) EFIAPI;
+
+    efi_status (*Start) (struct efi_driver_binding_protocol* self,
+                         efi_handle controller_handle,
+                         efi_device_path_protocol* remaining_path) EFIAPI;
+
+    efi_status (*Stop) (struct efi_driver_binding_protocol* self,
+                        efi_handle controller_handle,
+                        size_t num_children, efi_handle* child_handle_buf) EFIAPI;
+
+    uint32_t Version;
+    efi_handle ImageHandle;
+    efi_handle DriverBindingHandle;
+} efi_driver_binding_protocol;
diff --git a/include/efi/protocol/file.h b/include/efi/protocol/file.h
new file mode 100644
index 0000000..5477bc6
--- /dev/null
+++ b/include/efi/protocol/file.h
@@ -0,0 +1,97 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+#include <efi/boot-services.h>
+#include <efi/runtime-services.h>
+
+#define EFI_FILE_PROTOCOL_REVISION        0x00010000
+#define EFI_FILE_PROTOCOL_REVISION2       0x00020000
+#define EFI_FILE_PROTOCOL_LATEST_REVISION EFI_FILE_PROTOCOL_REVISION2
+
+#define EFI_FILE_MODE_READ   0x0000000000000001
+#define EFI_FILE_MODE_WRITE  0x0000000000000002
+#define EFI_FILE_MODE_CREATE 0x8000000000000000
+
+#define EFI_FILE_READ_ONLY  0x0000000000000001
+#define EFI_FILE_HIDDEN     0x0000000000000002
+#define EFI_FILE_SYSTEM     0x0000000000000004
+#define EFI_FILE_RESERVED   0x0000000000000008
+#define EFI_FILE_DIRECTORY  0x0000000000000010
+#define EFI_FILE_ARCHIVE    0x0000000000000020
+#define EFI_FILE_VALID_ATTR 0x0000000000000037
+
+typedef struct {
+    efi_event Event;
+    efi_status Status;
+    size_t BufferSize;
+    void* Buffer;
+} efi_file_io_token;
+
+#define EFI_FILE_INFO_GUID \
+    {0x09576e92, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}
+extern efi_guid FileInfoGuid;
+
+typedef struct {
+    uint64_t Size;
+    uint64_t FileSize;
+    uint64_t PhysicalSize;
+    efi_time CreateTime;
+    efi_time LastAccessTime;
+    efi_time ModificationTime;
+    uint64_t Attribute;
+    char16_t FileName[];
+} efi_file_info;
+
+#define EFI_FILE_SYSTEM_INFO_GUID \
+    {0x09576e93, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}
+extern efi_guid FileSystemInfoGuid;
+
+typedef struct {
+    uint64_t Size;
+    bool ReadOnly;
+    uint64_t VolumeSize;
+    uint64_t FreeSpace;
+    uint32_t BlockSize;
+    char16_t* VolumeLabel[];
+} efi_file_system_info;
+
+typedef struct efi_file_protocol {
+    uint64_t Revision;
+
+    efi_status (*Open) (struct efi_file_protocol* self, struct efi_file_protocol** new_handle,
+                        char16_t* filename, uint64_t open_mode, uint64_t attributes) EFIAPI;
+
+    efi_status (*Close) (struct efi_file_protocol* self) EFIAPI;
+
+    efi_status (*Delete) (struct efi_file_protocol* self) EFIAPI;
+
+    efi_status (*Read) (struct efi_file_protocol* self, size_t* len, void* buf) EFIAPI;
+
+    efi_status (*Write) (struct efi_file_protocol* self, size_t* len, void* buf) EFIAPI;
+
+    efi_status (*GetPosition) (struct efi_file_protocol* self, uint64_t* position) EFIAPI;
+
+    efi_status (*SetPosition) (struct efi_file_protocol* self, uint64_t position) EFIAPI;
+
+    efi_status (*GetInfo) (struct efi_file_protocol* self, efi_guid* info_type,
+                           size_t* buf_size, void* buf) EFIAPI;
+
+    efi_status (*SetInfo) (struct efi_file_protocol* self, efi_guid* info_type,
+                           size_t buf_size, void* buf) EFIAPI;
+
+    efi_status (*Flush) (struct efi_file_protocol* self) EFIAPI;
+
+    efi_status (*OpenEx) (struct efi_file_protocol* self, struct efi_file_protocol* new_handle,
+                          char16_t* filename, uint64_t open_mode, uint64_t attributes,
+                          efi_file_io_token* token) EFIAPI;
+
+    efi_status (*ReadEx) (struct efi_file_protocol* self, efi_file_io_token* token) EFIAPI;
+
+    efi_status (*WriteEx) (struct efi_file_protocol* self, efi_file_io_token* token) EFIAPI;
+
+    efi_status (*FlushEx) (struct efi_file_protocol* self, efi_file_io_token* token) EFIAPI;
+} efi_file_protocol;
diff --git a/include/efi/protocol/graphics-output.h b/include/efi/protocol/graphics-output.h
new file mode 100644
index 0000000..772cf06
--- /dev/null
+++ b/include/efi/protocol/graphics-output.h
@@ -0,0 +1,76 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+
+#define EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID \
+    {0x9042a9de, 0x23dc, 0x4a38, {0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a}}
+extern efi_guid GraphicsOutputProtocol;
+
+typedef struct {
+    uint32_t RedMask;
+    uint32_t GreenMask;
+    uint32_t BlueMask;
+    uint32_t ReservedMask;
+} efi_pixel_bitmask;
+
+typedef enum {
+    PixelRedGreenBlueReserved8BitPerColor,
+    PixelBlueGreenRedReserved8BitPerColor,
+    PixelBitMask,
+    PixelBltOnly,
+    PixelFormatMax
+} efi_graphics_pixel_format;
+
+typedef struct {
+    uint32_t Version;
+    uint32_t HorizontalResolution;
+    uint32_t VerticalResolution;
+    efi_graphics_pixel_format PixelFormat;
+    efi_pixel_bitmask PixelInformation;
+    uint32_t PixelsPerScanLine;
+} efi_graphics_output_mode_information;
+
+typedef struct {
+    uint32_t MaxMode;
+    uint32_t Mode;
+    efi_graphics_output_mode_information* Info;
+    size_t SizeOfInfo;
+    efi_physical_addr FrameBufferBase;
+    size_t FrameBufferSize;
+} efi_graphics_output_mode;
+
+typedef struct {
+    uint8_t Blue;
+    uint8_t Green;
+    uint8_t Red;
+    uint8_t Reserved;
+} efi_graphics_output_blt_pixel;
+
+typedef enum {
+    EfiBltVideoFill,
+    EfiBltVideoToBltBuffer,
+    EfiBltBufferToVideo,
+    EfiBltVideoToVideo,
+    EfiGraphicsOutputBltOperationMax
+} efi_graphics_output_blt_operation;
+
+typedef struct efi_graphics_output_protocol {
+    efi_status (*QueryMode) (struct efi_graphics_output_protocol* self,
+                             uint32_t mode_num, size_t* info_len,
+                             efi_graphics_output_mode_information** info) EFIAPI;
+
+    efi_status (*SetMode) (struct efi_graphics_output_protocol* self,
+                           uint32_t mode_num) EFIAPI;
+
+    efi_status (*Blt) (struct efi_graphics_output_protocol* self,
+                       efi_graphics_output_blt_pixel* blt_buf,
+                       efi_graphics_output_blt_operation blt_operation,
+                       size_t src_x, size_t src_y, size_t dest_x, size_t dest_y,
+                       size_t width, size_t height, size_t delta) EFIAPI;
+
+    efi_graphics_output_mode* Mode;
+} efi_graphics_output_protocol;
diff --git a/include/efi/protocol/loaded-image.h b/include/efi/protocol/loaded-image.h
new file mode 100644
index 0000000..800d269
--- /dev/null
+++ b/include/efi/protocol/loaded-image.h
@@ -0,0 +1,32 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+#include <efi/system-table.h>
+#include <efi/protocol/device-path.h>
+
+#define EFI_LOADED_IMAGE_PROTOCOL_GUID \
+    {0x5b1b31a1, 0x9562, 0x11d2, {0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}
+extern efi_guid LoadedImageProtocol;
+
+#define EFI_LOADED_IMAGE_PROTOCOL_REVISION 0x1000
+
+typedef struct {
+    uint32_t Revision;
+    efi_handle ParentHandle;
+    efi_system_table* SystemTable;
+    efi_handle DeviceHandle;
+    efi_device_path_protocol* FilePath;
+    void* Reserved;
+    uint32_t LoadOptionsSize;
+    void* LoadOptions;
+    void* ImageBase;
+    uint64_t ImageSize;
+    efi_memory_type ImageCodeType;
+    efi_memory_type ImageDataType;
+
+    efi_status (*Unload) (efi_handle img) EFIAPI;
+} efi_loaded_image_protocol;
diff --git a/include/efi/protocol/managed-network.h b/include/efi/protocol/managed-network.h
index e9aafc3..2147054 100644
--- a/include/efi/protocol/managed-network.h
+++ b/include/efi/protocol/managed-network.h
@@ -4,106 +4,89 @@
 
 #pragma once
 
-#include <efi.h>
+#include <efi/types.h>
+#include <efi/protocol/simple-network.h>
 
 #define EFI_MANAGED_NETWORK_PROTOCOL_GUID \
     {0x7ab33a91, 0xace5, 0x4326,{0xb5, 0x72, 0xe7, 0xee, 0x33, 0xd3, 0x9f, 0x16}}
-
-EFI_GUID ManagedNetworkProtocol = EFI_MANAGED_NETWORK_PROTOCOL_GUID;
-
-struct _EFI_MANAGED_NETWORK_PROTOCOL;
+extern efi_guid ManagedNetworkProtocol;
 
 typedef struct {
-    EFI_TIME  Timestamp;
-    EFI_EVENT RecycleEvent;
-    UINT32 PacketLength;
-    UINT32 HeaderLength;
-    UINT32 AddressLength;
-    UINT32 DataLength;
-    BOOLEAN BroadcastFlag;
-    BOOLEAN MulticastFlag;
-    BOOLEAN PromiscuousFlag;
-    UINT16  ProtocolType;
-    VOID *DestinationAddress;
-    VOID *SourceAddress;
-    VOID *MediaHeader;
-    VOID *PacketData;
-} EFI_MANAGED_NETWORK_RECEIVE_DATA;
+    efi_time  Timestamp;
+    efi_event RecycleEvent;
+    uint32_t PacketLength;
+    uint32_t HeaderLength;
+    uint32_t AddressLength;
+    uint32_t DataLength;
+    bool BroadcastFlag;
+    bool MulticastFlag;
+    bool PromiscuousFlag;
+    uint16_t  ProtocolType;
+    void* DestinationAddress;
+    void* SourceAddress;
+    void* MediaHeader;
+    void* PacketData;
+} efi_managed_network_receive_data;
 
 typedef struct {
-    UINT32 FragmentLength;
-    VOID *FragmentBuffer;
-} EFI_MANAGED_NETWORK_FRAGMENT_DATA;
+    uint32_t FragmentLength;
+    void* FragmentBuffer;
+} efi_managed_network_fragment_data;
 
 typedef struct {
-    EFI_MAC_ADDRESS *DestinationAddress;
-    EFI_MAC_ADDRESS *SourceAddress;
-    UINT16 ProtocolType;
-    UINT32 DataLength;
-    UINT16 HeaderLength;
-    UINT16 FragmentCount;
-    EFI_MANAGED_NETWORK_FRAGMENT_DATA FragmentTable[1];
-} EFI_MANAGED_NETWORK_TRANSMIT_DATA;
+    efi_mac_addr* DestinationAddress;
+    efi_mac_addr* SourceAddress;
+    uint16_t ProtocolType;
+    uint32_t DataLength;
+    uint16_t HeaderLength;
+    uint16_t FragmentCount;
+    efi_managed_network_fragment_data FragmentTable[1];
+} efi_managed_network_transmit_data;
 
 typedef struct {
-    EFI_EVENT Event;
-    EFI_STATUS Status;
+    uint32_t ReceivedQueueTimeoutValue;
+    uint32_t TransmitQueueTimeoutValue;
+    uint16_t ProtocolTypeFilter;
+    bool EnableUnicastReceive;
+    bool EnableMulticastReceive;
+    bool EnableBroadcastReceive;
+    bool EnablePromiscuousReceive;
+    bool FlushQueuesOnReset;
+    bool EnableReceiveTimestamps;
+    bool DisableBackgroundPolling;
+} efi_managed_network_config_data;
+
+typedef struct {
+    efi_event Event;
+    efi_status Status;
     union {
-        EFI_MANAGED_NETWORK_RECEIVE_DATA *RxData;
-        EFI_MANAGED_NETWORK_TRANSMIT_DATA *TxData;
+        efi_managed_network_receive_data* RxData;
+        efi_managed_network_transmit_data* TxData;
     } Packet;
-} EFI_MANAGED_NETWORK_COMPLETION_TOKEN;
+} efi_managed_network_completion_token;
 
-typedef EFI_STATUS (EFIAPI *EFI_MANAGED_NETWORK_GET_MODE_DATA) (
-    IN  struct _EFI_MANAGED_NETWORK_PROTOCOL     *This,
-    OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData OPTIONAL,
-    OUT EFI_SIMPLE_NETWORK_MODE         *SnpModeData OPTIONAL
-);
+typedef struct efi_managed_network_protocol {
+    efi_status (*GetModeData) (struct efi_managed_network_protocol* self,
+                               efi_managed_network_config_data* mnp_config_data,
+                               efi_simple_network_mode* snp_mode_data) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_MANAGED_NETWORK_CONFIGURE) (
-    IN struct _EFI_MANAGED_NETWORK_PROTOCOL *This,
-    IN EFI_MANAGED_NETWORK_CONFIG_DATA      *MnpConfigData OPTIONAL
-);
+    efi_status (*Configure) (struct efi_managed_network_protocol* self,
+                             efi_managed_network_config_data* mnp_config_data) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_MANAGED_NETWORK_MCAST_IP_TO_MAC) (
-    IN struct _EFI_MANAGED_NETWORK_PROTOCOL *This,
-    IN BOOLEAN                              Ipv6Flag,
-    IN EFI_IP_ADDRESS                       *IpAddress,
-    OUT EFI_MAC_ADDRESS                     *MacAddress
-);
+    efi_status (*McastIpToMac) (struct efi_managed_network_protocol* self,
+                                bool ipv6_flag, efi_ip_addr* ip_addr, efi_mac_addr* mac_addr) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_MANAGED_NETWORK_GROUPS) (
-    IN struct _EFI_MANAGED_NETWORK_PROTOCOL *This,
-    IN BOOLEAN                              JoinFlag,
-    IN EFI_MAC_ADDRESS                      *MacAddress OPTIONAL
-);
+    efi_status (*Groups) (struct efi_managed_network_protocol* self, bool join_flag,
+                          efi_mac_addr* mac_addr) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_MANAGED_NETWORK_TRANSMIT) (
-    IN struct _EFI_MANAGED_NETWORK_PROTOCOL *This,
-    IN EFI_MANAGED_NETWORK_COMPLETION_TOKEN *Token
-);
+    efi_status (*Transmit) (struct efi_managed_network_protocol* self,
+                            efi_managed_network_completion_token* token) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_MANAGED_NETWORK_RECEIVE) (
-    IN struct _EFI_MANAGED_NETWORK_PROTOCOL *This,
-    IN EFI_MANAGED_NETWORK_COMPLETION_TOKEN *Token
-);
+    efi_status (*Receive) (struct efi_managed_network_protocol* self,
+                           efi_managed_network_completion_token* token) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_MANAGED_NETWORK_CANCEL)(
-    IN struct _EFI_MANAGED_NETWORK_PROTOCOL *This,
-    IN EFI_MANAGED_NETWORK_COMPLETION_TOKEN *Token OPTIONAL
-);
+    efi_status (*Cancel) (struct efi_managed_network_protocol* self,
+                          efi_managed_network_completion_token* token) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_MANAGED_NETWORK_POLL) (
-    IN struct _EFI_MANAGED_NETWORK_PROTOCOL *This
-);
-
-typedef struct _EFI_MANAGED_NETWORK {
-    EFI_MANAGED_NETWORK_GET_MODE_DATA   GetModeData;
-    EFI_MANAGED_NETWORK_CONFIGURE       Configure;
-    EFI_MANAGED_NETWORK_MCAST_IP_TO_MAC McastIpToMac;
-    EFI_MANAGED_NETWORK_GROUPS          Groups;
-    EFI_MANAGED_NETWORK_TRANSMIT        Transmit;
-    EFI_MANAGED_NETWORK_RECEIVE         Receive;
-    EFI_MANAGED_NETWORK_CANCEL          Cancel;
-    EFI_MANAGED_NETWORK_POLL            Poll;
-} EFI_MANAGED_NETWORK;
+    efi_status (*Poll) (struct efi_managed_network_protocol* self) EFIAPI;
+} efi_managed_network_protocol;
diff --git a/include/efi/protocol/pci-root-bridge-io.h b/include/efi/protocol/pci-root-bridge-io.h
index 3e66ce2..1e54f89 100644
--- a/include/efi/protocol/pci-root-bridge-io.h
+++ b/include/efi/protocol/pci-root-bridge-io.h
@@ -4,14 +4,12 @@
 
 #pragma once
 
-#include <efi.h>
+#include <efi/boot-services.h>
+#include <efi/types.h>
 
 #define EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID \
     {0x2f707ebb, 0x4a1a, 0x11D4, {0x9a, 0x38, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d}}
-
-EFI_GUID PciRootBridgeIoProtocol = EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID;
-
-struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL;
+extern efi_guid PciRootBridgeIoProtocol;
 
 typedef enum {
     EfiPciWidthUint8,
@@ -27,30 +25,18 @@
     EfiPciWidthFillUint32,
     EfiPciWidthFillUint64,
     EfiPciWidthMaximum,
-} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH;
+} efi_pci_root_bridge_io_width;
 
-typedef EFI_STATUS (EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM) (
-    IN  struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This,
-    IN  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH   Width,
-    IN  UINT64                                  Address,
-    IN  UINT64                                  Mask,
-    IN  UINT64                                  Value,
-    IN  UINT64                                  Delay,
-    OUT UINT64                                  *Result
-);
-
-typedef EFI_STATUS (EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM) (
-    IN     struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This,
-    IN     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH   Width,
-    IN     UINT64                                  Address,
-    IN     UINTN                                   Count,
-    IN OUT VOID                                    *Buffer
-);
+struct efi_pci_root_bridge_io_protocol;
 
 typedef struct {
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM Read;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM Write;
-} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS;
+    efi_status (*Read) (struct efi_pci_root_bridge_io_protocol* self,
+                        efi_pci_root_bridge_io_width   width,
+                        uint64_t addr, size_t count, void* buffer) EFIAPI;
+    efi_status (*Write) (struct efi_pci_root_bridge_io_protocol* self,
+                         efi_pci_root_bridge_io_width   width,
+                         uint64_t addr, size_t count, void* buffer) EFIAPI;
+} efi_pci_root_bridge_io_access;
 
 #define EFI_PCI_ATTRIBUTE_ISA_MOTHERBOARD_IO 0x0001
 #define EFI_PCI_ATTRIBUTE_ISA_IO 0x0002
@@ -75,82 +61,55 @@
     EfiPciOperationBusMasterWrite64,
     EfiPciOperationBusMasterCommonBuffer64,
     EfiPciOperationMaximum,
-} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_OPERATION;
+} efi_pci_root_bridge_io_operation;
 
-typedef EFI_STATUS (EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_COPY_MEM) (
-    IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This,
-    IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH   Width,
-    IN UINT64                                  DestAddress,
-    IN UINT64                                  SrcAddress,
-    IN UINTN                                   Count
-);
+typedef struct efi_pci_root_bridge_io_protocol {
+    efi_handle ParentHandle;
 
-typedef EFI_STATUS (EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_MAP) (
-    IN  struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL   *This,
-    IN  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_OPERATION Operation,
-    IN  VOID                                      *HostAddress,
-    IN  OUT UINTN                                 *NumberOfBytes,
-    OUT EFI_PHYSICAL_ADDRESS                      *DeviceAddress,
-    OUT VOID                                      **Mapping
-);
+    efi_status (*PollMem) (struct efi_pci_root_bridge_io_protocol *self,
+                           efi_pci_root_bridge_io_width width,
+                           uint64_t addr, uint64_t mask, uint64_t value, uint64_t delay,
+                           uint64_t* result) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_UNMAP) (
-    IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This,
-    IN VOID                                    *Mapping
-);
+    efi_status (*PollIo) (struct efi_pci_root_bridge_io_protocol *self,
+                          efi_pci_root_bridge_io_width width,
+                          uint64_t addr, uint64_t mask, uint64_t value, uint64_t delay,
+                          uint64_t* result) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ALLOCATE_BUFFER) (
-    IN  struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This,
-    IN  EFI_ALLOCATE_TYPE                       Type,
-    IN  EFI_MEMORY_TYPE                         MemoryType,
-    IN  UINTN                                   Pages,
-    OUT VOID                                    **HostAddress,
-    IN  UINT64                                  Attributes
-);
+    efi_pci_root_bridge_io_access Mem;
+    efi_pci_root_bridge_io_access Io;
+    efi_pci_root_bridge_io_access Pci;
 
-typedef EFI_STATUS (EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FREE_BUFFER) (
-    IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This,
-    IN UINTN                                   Pages,
-    IN VOID                                    *HostAddress
-);
+    efi_status (*CopyMem) (struct efi_pci_root_bridge_io_protocol* self,
+                           efi_pci_root_bridge_io_width width,
+                           uint64_t dest_addr, uint64_t src_addr, size_t count) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FLUSH) (
-    IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This
-);
+    efi_status (*Map) (struct efi_pci_root_bridge_io_protocol* self,
+                       efi_pci_root_bridge_io_operation operation,
+                       void* host_addr, size_t* num_bytes,
+                       efi_physical_addr* device_addr, void** mapping) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GET_ATTRIBUTES) (
-    IN  struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This,
-    OUT UINT64                                  *Supports   OPTIONAL,
-    OUT UINT64                                  *Attributes OPTIONAL
-);
+    efi_status (*Unmap) (struct efi_pci_root_bridge_io_protocol* self,
+                         void* mapping) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_SET_ATTRIBUTES) (
-    IN     struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This,
-    IN     UINT64                                  Attributes,
-    IN OUT UINT64                                  *ResourceBase   OPTIONAL,
-    IN OUT UINT64                                  *ResourceLength OPTIONAL
-);
+    efi_status (*AllocateBuffer) (struct efi_pci_root_bridge_io_protocol* self,
+                                  efi_allocate_type type, efi_memory_type memory_type,
+                                  size_t pages, void** host_addr, uint64_t attributes) EFIAPI;
 
-typedef EFI_STATUS (EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_CONFIGURATION) (
-    IN  struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *This,
-    OUT VOID                                    **Resources
-);
+    efi_status (*FreeBuffer) (struct efi_pci_root_bridge_io_protocol* self,
+                              size_t pages, void* host_addr) EFIAPI;
 
-typedef struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL {
-    EFI_HANDLE ParentHandle;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM PollMem;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM PollIo;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS Mem;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS Io;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS Pci;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_COPY_MEM CopyMem;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_MAP Map;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_UNMAP Unmap;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ALLOCATE_BUFFER AllocateBuffer;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FREE_BUFFER FreeBuffer;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FLUSH Flush;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GET_ATTRIBUTES GetAttributes;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_SET_ATTRIBUTES SetAttributes;
-    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_CONFIGURATION Configuration;
-    UINT32 SegmentNumber;
-} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL;
+    efi_status (*Flush) (struct efi_pci_root_bridge_io_protocol* self) EFIAPI;
+
+    efi_status (*GetAttributes) (struct efi_pci_root_bridge_io_protocol* self,
+                                 uint64_t* supports, uint64_t* attributes) EFIAPI;
+
+    efi_status (*SetAttributes) (struct efi_pci_root_bridge_io_protocol* self,
+                                 uint64_t attributes, uint64_t* resource_base,
+                                 uint64_t* resource_len) EFIAPI;
+
+    efi_status (*Configuration) (struct efi_pci_root_bridge_io_protocol* self,
+                                 void** resources) EFIAPI;
+
+    uint32_t SegmentNumber;
+} efi_pci_root_bridge_io_protocol;
diff --git a/include/efi/protocol/simple-file-system.h b/include/efi/protocol/simple-file-system.h
new file mode 100644
index 0000000..ad7c42a
--- /dev/null
+++ b/include/efi/protocol/simple-file-system.h
@@ -0,0 +1,21 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+#include <efi/protocol/file.h>
+
+#define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID \
+    {0x0964e5b22, 0x6459, 0x11d2, {0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}
+extern efi_guid SimpleFileSystemProtocol;
+
+#define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION 0x00010000
+
+typedef struct efi_simple_file_system_protocol {
+    uint64_t Revision;
+
+    efi_status (*OpenVolume) (struct efi_simple_file_system_protocol* self,
+                              efi_file_protocol** root) EFIAPI;
+} efi_simple_file_system_protocol;
diff --git a/include/efi/protocol/simple-network.h b/include/efi/protocol/simple-network.h
new file mode 100644
index 0000000..b4e3489
--- /dev/null
+++ b/include/efi/protocol/simple-network.h
@@ -0,0 +1,131 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+
+#define EFI_SIMPLE_NETWORK_PROTOCOL_GUID \
+    {0xa19832b9, 0xac25, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d}}
+extern efi_guid SimpleNetworkProtocol;
+
+#define EFI_SIMPLE_NETWORK_PROTOCOL_REVISION 0x00010000
+
+#define MAX_MCAST_FILTER_CNT 16
+typedef struct {
+    uint32_t State;
+    uint32_t HwAddressSize;
+    uint32_t MediaHeaderSize;
+    uint32_t MaxPacketSize;
+    uint32_t NvRamSize;
+    uint32_t NvRamAccessSize;
+    uint32_t ReceiveFilterMask;
+    uint32_t ReceiveFilterSetting;
+    uint32_t MaxMCastFilterCount;
+    uint32_t MCastFilterCount;
+    efi_mac_addr MCastFilter[MAX_MCAST_FILTER_CNT];
+    efi_mac_addr CurrentAddress;
+    efi_mac_addr BroadcastAddress;
+    efi_mac_addr PermanentAddress;
+    uint8_t IfType;
+    bool MacAddressChangeable;
+    bool MultipleTxSupported;
+    bool MediaPresentSupported;
+    bool MediaPresent;
+} efi_simple_network_mode;
+
+typedef enum {
+    EfiSimpleNetworkStopped,
+    EfiSimpleNetworkStarted,
+    EfiSimpleNetworkInitialized,
+    EfiSimpleNetworkMaxState
+} efi_simple_network_state;
+
+#define EFI_SIMPLE_NETWORK_RECEIVE_UNICAST               0x01
+#define EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST             0x02
+#define EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST             0x04
+#define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS           0x08
+#define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST 0x10
+
+typedef struct {
+    uint64_t RxTotalFrames;
+    uint64_t RxGoodFrames;
+    uint64_t RxUndersizeFrames;
+    uint64_t RxOversizeFrames;
+    uint64_t RxDroppedFrames;
+    uint64_t RxUnicastFrames;
+    uint64_t RxBroadcastFrames;
+    uint64_t RxMulticastFrames;
+    uint64_t RxCrcErrorFrames;
+    uint64_t RxTotalBytes;
+    uint64_t TxTotalFrames;
+    uint64_t TxGoodFrames;
+    uint64_t TxUndersizeFrames;
+    uint64_t TxOversizeFrames;
+    uint64_t TxDroppedFrames;
+    uint64_t TxUnicastFrames;
+    uint64_t TxBroadcastFrames;
+    uint64_t TxMulticastFrames;
+    uint64_t TxCrcErrorFrames;
+    uint64_t TxTotalBytes;
+    uint64_t Collisions;
+    uint64_t UnsupportedProtocol;
+    uint64_t RxDuplicatedFrames;
+    uint64_t RxDecryptErrorFrames;
+    uint64_t TxErrorFrames;
+    uint64_t TxRetryFrames;
+} efi_network_statistics;
+
+#define EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT  0x01
+#define EFI_SIMPLE_NETWORK_TRANSMIT_INTERRUPT 0x02
+#define EFI_SIMPLE_NETWORK_COMMAND_INTERRUPT  0x04
+#define EFI_SIMPLE_NETWORK_SOFTWARE_INTERRUPT 0x08
+
+typedef struct efi_simple_network_protocol {
+    uint64_t Revision;
+
+    efi_status (*Start) (struct efi_simple_network_protocol* self) EFIAPI;
+
+    efi_status (*Stop) (struct efi_simple_network_protocol* self) EFIAPI;
+
+    efi_status (*Initialize) (struct efi_simple_network_protocol* self,
+                              size_t extra_rx_buf_size, size_t extra_tx_buf_size) EFIAPI;
+
+    efi_status (*Reset) (struct efi_simple_network_protocol* self,
+                         bool extended_verification) EFIAPI;
+
+    efi_status (*Shutdown) (struct efi_simple_network_protocol* self) EFIAPI;
+
+    efi_status (*ReceiveFilters) (struct efi_simple_network_protocol* self,
+                                  uint32_t enable, uint32_t disable,
+                                  bool reset_mcast_filter, size_t mcast_filter_count,
+                                  efi_mac_addr* mcast_filter) EFIAPI;
+
+    efi_status (*StationAddress) (struct efi_simple_network_protocol* self,
+                                  bool reset, efi_mac_addr* new_addr) EFIAPI;
+
+    efi_status (*Statistics) (struct efi_simple_network_protocol* self,
+                              bool reset, size_t* stats_size,
+                              efi_network_statistics* stats_table) EFIAPI;
+
+    efi_status (*MCastIpToMac) (struct efi_simple_network_protocol* self,
+                                bool ipv6, efi_ip_addr* ip, efi_mac_addr* mac) EFIAPI;
+
+    efi_status (*NvData) (struct efi_simple_network_protocol* self,
+                          bool read_write, size_t offset, size_t buf_size, void* buf) EFIAPI;
+
+    efi_status (*GetStatus) (struct efi_simple_network_protocol* self,
+                             uint32_t* interrupt_status, void** tx_buf) EFIAPI;
+
+    efi_status (*Transmit) (struct efi_simple_network_protocol* self,
+                            size_t header_size, size_t buf_size, void* buf,
+                            efi_mac_addr* src, efi_mac_addr* dest, uint16_t* protocol) EFIAPI;
+
+    efi_status (*Receive) (struct efi_simple_network_protocol* self,
+                           size_t* header_size, size_t* buf_size, void* buf,
+                           efi_mac_addr* src, efi_mac_addr* dest, uint16_t* protocol) EFIAPI;
+
+    efi_event WaitForPacket;
+    efi_simple_network_mode* Mode;
+} efi_simple_network_protocol;
diff --git a/include/efi/protocol/simple-text-input.h b/include/efi/protocol/simple-text-input.h
new file mode 100644
index 0000000..ee6bf68
--- /dev/null
+++ b/include/efi/protocol/simple-text-input.h
@@ -0,0 +1,26 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+
+#define EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID \
+    {0x387477c1, 0x69c7, 0x11d2, {0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}
+extern efi_guid SimpleTextInputProtocol;
+
+typedef struct {
+    uint16_t ScanCode;
+    char16_t UnicodeChar;
+} efi_input_key;
+
+typedef struct efi_simple_text_input_protocol {
+    efi_status (*Reset) (struct efi_simple_text_input_protocol* self,
+                         bool extendend_verification) EFIAPI;
+
+    efi_status (*ReadKeyStroke) (struct efi_simple_text_input_protocol* self,
+                                 efi_input_key* key) EFIAPI;
+
+    efi_event WaitForKey;
+} efi_simple_text_input_protocol;
diff --git a/include/efi/protocol/simple-text-output.h b/include/efi/protocol/simple-text-output.h
new file mode 100644
index 0000000..ac93167
--- /dev/null
+++ b/include/efi/protocol/simple-text-output.h
@@ -0,0 +1,143 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+
+#define EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID \
+    {0x387477c2, 0x69c7, 0x11d2, {0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}
+extern efi_guid SimpleTextOutputProtocol;
+
+typedef struct {
+    int32_t MaxMode;
+    int32_t Mode;
+    int32_t Attribute;
+    int32_t CursorColumn;
+    int32_t CursorRow;
+    bool CursorVisible;
+} simple_text_output_mode;
+
+//*******************************************************
+// UNICODE DRAWING CHARACTERS
+//*******************************************************
+#define BOXDRAW_HORIZONTAL 0x2500
+#define BOXDRAW_VERTICAL 0x2502
+#define BOXDRAW_DOWN_RIGHT 0x250c
+#define BOXDRAW_DOWN_LEFT 0x2510
+#define BOXDRAW_UP_RIGHT 0x2514
+#define BOXDRAW_UP_LEFT 0x2518
+#define BOXDRAW_VERTICAL_RIGHT 0x251c
+#define BOXDRAW_VERTICAL_LEFT 0x2524
+#define BOXDRAW_DOWN_HORIZONTAL 0x252c
+#define BOXDRAW_UP_HORIZONTAL 0x2534
+#define BOXDRAW_VERTICAL_HORIZONTAL 0x253c
+#define BOXDRAW_DOUBLE_HORIZONTAL 0x2550
+#define BOXDRAW_DOUBLE_VERTICAL 0x2551
+#define BOXDRAW_DOWN_RIGHT_DOUBLE 0x2552
+#define BOXDRAW_DOWN_DOUBLE_RIGHT 0x2553
+#define BOXDRAW_DOUBLE_DOWN_RIGHT 0x2554
+#define BOXDRAW_DOWN_LEFT_DOUBLE 0x2555
+#define BOXDRAW_DOWN_DOUBLE_LEFT 0x2556
+#define BOXDRAW_DOUBLE_DOWN_LEFT 0x2557
+#define BOXDRAW_UP_RIGHT_DOUBLE 0x2558
+#define BOXDRAW_UP_DOUBLE_RIGHT 0x2559
+#define BOXDRAW_DOUBLE_UP_RIGHT 0x255a
+#define BOXDRAW_UP_LEFT_DOUBLE 0x255b
+#define BOXDRAW_UP_DOUBLE_LEFT 0x255c
+#define BOXDRAW_DOUBLE_UP_LEFT 0x255d
+#define BOXDRAW_VERTICAL_RIGHT_DOUBLE 0x255e
+#define BOXDRAW_VERTICAL_DOUBLE_RIGHT 0x255f
+#define BOXDRAW_DOUBLE_VERTICAL_RIGHT 0x2560
+#define BOXDRAW_VERTICAL_LEFT_DOUBLE 0x2561
+#define BOXDRAW_VERTICAL_DOUBLE_LEFT 0x2562
+#define BOXDRAW_DOUBLE_VERTICAL_LEFT 0x2563
+#define BOXDRAW_DOWN_HORIZONTAL_DOUBLE 0x2564
+#define BOXDRAW_DOWN_DOUBLE_HORIZONTAL 0x2565
+#define BOXDRAW_DOUBLE_DOWN_HORIZONTAL 0x2566
+#define BOXDRAW_UP_HORIZONTAL_DOUBLE 0x2567
+#define BOXDRAW_UP_DOUBLE_HORIZONTAL 0x2568
+#define BOXDRAW_DOUBLE_UP_HORIZONTAL 0x2569
+#define BOXDRAW_VERTICAL_HORIZONTAL_DOUBLE 0x256a
+#define BOXDRAW_VERTICAL_DOUBLE_HORIZONTAL 0x256b
+#define BOXDRAW_DOUBLE_VERTICAL_HORIZONTAL 0x256c
+
+//*******************************************************
+// EFI Required Block Elements Code Chart
+//*******************************************************
+#define BLOCKELEMENT_FULL_BLOCK 0x2588
+#define BLOCKELEMENT_LIGHT_SHADE 0x2591
+
+//*******************************************************
+// EFI Required Geometric Shapes Code Chart
+//*******************************************************
+#define GEOMETRICSHAPE_UP_TRIANGLE 0x25b2
+#define GEOMETRICSHAPE_RIGHT_TRIANGLE 0x25ba
+#define GEOMETRICSHAPE_DOWN_TRIANGLE 0x25bc
+#define GEOMETRICSHAPE_LEFT_TRIANGLE 0x25c4
+
+//*******************************************************
+// EFI Required Arrow shapes
+//*******************************************************
+#define ARROW_UP 0x2191
+#define ARROW_DOWN 0x2193
+
+//*******************************************************
+// Attributes
+//*******************************************************
+#define EFI_BLACK 0x00
+#define EFI_BLUE 0x01
+#define EFI_GREEN 0x02
+#define EFI_CYAN 0x03
+#define EFI_RED 0x04
+#define EFI_MAGENTA 0x05
+#define EFI_BROWN 0x06
+#define EFI_LIGHTGRAY 0x07
+#define EFI_BRIGHT 0x08
+#define EFI_DARKGRAY 0x08
+#define EFI_LIGHTBLUE 0x09
+#define EFI_LIGHTGREEN 0x0A
+#define EFI_LIGHTCYAN 0x0B
+#define EFI_LIGHTRED 0x0C
+#define EFI_LIGHTMAGENTA 0x0D
+#define EFI_YELLOW 0x0E
+#define EFI_WHITE 0x0F
+#define EFI_BACKGROUND_BLACK 0x00
+#define EFI_BACKGROUND_BLUE 0x10
+#define EFI_BACKGROUND_GREEN 0x20
+#define EFI_BACKGROUND_CYAN 0x30
+#define EFI_BACKGROUND_RED 0x40
+#define EFI_BACKGROUND_MAGENTA 0x50
+#define EFI_BACKGROUND_BROWN 0x60
+#define EFI_BACKGROUND_LIGHTGRAY 0x70
+
+typedef struct efi_simple_text_output_protocol {
+    efi_status (*Reset) (struct efi_simple_text_output_protocol* self,
+                         bool extended_verification) EFIAPI;
+
+    efi_status (*OutputString) (struct efi_simple_text_output_protocol* self,
+                                char16_t* string) EFIAPI;
+
+    efi_status (*TestString) (struct efi_simple_text_output_protocol* self,
+                              char16_t* string) EFIAPI;
+
+    efi_status (*QueryMode) (struct efi_simple_text_output_protocol* self,
+                             size_t mode_num, size_t* cols, size_t* rows) EFIAPI;
+
+    efi_status (*SetMode) (struct efi_simple_text_output_protocol* self,
+                           size_t mode_num) EFIAPI;
+
+    efi_status (*SetAttribute) (struct efi_simple_text_output_protocol* self,
+                                size_t attribute) EFIAPI;
+
+    efi_status (*ClearScreen) (struct efi_simple_text_output_protocol* self) EFIAPI;
+
+    efi_status (*SetCursorPosition) (struct efi_simple_text_output_protocol* self,
+                                     size_t col, size_t row) EFIAPI;
+
+    efi_status (*EnableCursor) (struct efi_simple_text_output_protocol* self,
+                                bool visible) EFIAPI;
+
+    simple_text_output_mode* Mode;
+} efi_simple_text_output_protocol;
diff --git a/include/efi/protocol/usb-io.h b/include/efi/protocol/usb-io.h
new file mode 100644
index 0000000..721ce92
--- /dev/null
+++ b/include/efi/protocol/usb-io.h
@@ -0,0 +1,147 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+
+#define EFI_USB_IO_PROTOCOL_GUID \
+    {0x2b2f68d6, 0x0cd2, 0x44cf, {0x8e, 0x8b, 0xbb, 0xa2, 0x0b, 0x1b, 0x5b, 0x75}}
+extern efi_guid UsbIoProtocol;
+
+typedef enum {
+    EfiUsbDataIn,
+    EfiUsbDataOut,
+    EfiUsbNoData
+} efi_usb_data_direction;
+
+#define EFI_USB_NOERROR        0x0000
+#define EFI_USB_ERR_NOTEXECUTE 0x0001
+#define EFI_USB_ERR_STALL      0x0002
+#define EFI_USB_ERR_BUFFER     0x0004
+#define EFI_USB_ERR_BABBLE     0x0008
+#define EFI_USB_ERR_NAK        0x0010
+#define EFI_USB_ERR_CRC        0x0020
+#define EFI_USB_ERR_TIMEOUT    0x0040
+#define EFI_USB_ERR_BITSTUFF   0x0080
+#define EFI_USB_ERR_SYSTEM     0x0100
+
+typedef struct {
+    uint8_t  RequestType;
+    uint8_t  Request;
+    uint16_t Value;
+    uint16_t Index;
+    uint16_t Length;
+} efi_usb_device_request;
+
+typedef efi_status (*efi_async_usb_transfer_callback) (
+        void* Data, size_t DataLength, void* Context, uint32_t Status) EFIAPI;
+
+typedef struct {
+    uint8_t  Length;
+    uint8_t  DescriptorType;
+    uint16_t BcdUSB;
+    uint8_t  DeviceClass;
+    uint8_t  DeviceSubClass;
+    uint8_t  DeviceProtocol;
+    uint8_t  MaxPacketSize0;
+    uint16_t IdVendor;
+    uint16_t IdProduct;
+    uint16_t BcdDevice;
+    uint8_t  StrManufacturer;
+    uint8_t  StrProduct;
+    uint8_t  StrSerialNumber;
+    uint8_t  NumConfigurations;
+} efi_usb_device_descriptor;
+
+typedef struct {
+    uint8_t  Length;
+    uint8_t  DescriptorType;
+    uint16_t TotalLength;
+    uint8_t  NumInterfaces;
+    uint8_t  ConfigurationValue;
+    uint8_t  Configuration;
+    uint8_t  Attributes;
+    uint8_t  MaxPower;
+} efi_usb_config_descriptor;
+
+typedef struct {
+    uint8_t Length;
+    uint8_t DescriptorType;
+    uint8_t InterfaceNumber;
+    uint8_t AlternateSetting;
+    uint8_t NumEndpoints;
+    uint8_t InterfaceClass;
+    uint8_t InterfaceSubClass;
+    uint8_t InterfaceProtocol;
+    uint8_t Interface;
+} efi_usb_interface_descriptor;
+
+typedef struct {
+    uint8_t  Length;
+    uint8_t  DescriptorType;
+    uint8_t  EndpointAddress;
+    uint8_t  Attributes;
+    uint16_t MaxPacketSize;
+    uint8_t  Interval;
+} efi_usb_endpoint_descriptor;
+
+typedef struct efi_usb_io_protocol {
+    efi_status (*UsbControlTransfer) (struct efi_usb_io_protocol* self,
+                                      efi_usb_device_request* request,
+                                      efi_usb_data_direction direction,
+                                      uint32_t timeout, void* data,
+                                      size_t data_len, uint32_t* status) EFIAPI;
+
+    efi_status (*UsbBulkTransfer) (struct efi_usb_io_protocol* self,
+                                   uint8_t endpoint, void* data,
+                                   size_t data_len, size_t timeout,
+                                   uint32_t* status) EFIAPI;
+
+    efi_status (*UsbAsyncInterruptTransfer) (struct efi_usb_io_protocol* self,
+                                             uint8_t endpoint, bool is_new_transfer,
+                                             size_t polling_interval,
+                                             size_t data_len,
+                                             efi_async_usb_transfer_callback interrupt_cb,
+                                             void* context) EFIAPI;
+
+    efi_status (*UsbSyncInterruptTransfer) (struct efi_usb_io_protocol* self,
+                                            uint8_t endpoint, void* data,
+                                            size_t* data_len, size_t timeout,
+                                            uint32_t* status) EFIAPI;
+
+    efi_status (*UsbIsochronousTransfer) (struct efi_usb_io_protocol* self,
+                                          uint8_t endpoint,
+                                          void* data, size_t data_len,
+                                          uint32_t* status) EFIAPI;
+
+    efi_status (*UsbAsyncIsochronousTransfer) (struct efi_usb_io_protocol* self,
+                                               uint8_t endpoint,
+                                               void* data, size_t data_len,
+                                               efi_async_usb_transfer_callback isoc_cb,
+                                               void* context) EFIAPI;
+
+    efi_status (*UsbGetDeviceDescriptor) (struct efi_usb_io_protocol* self,
+                                          efi_usb_device_descriptor* descriptor) EFIAPI;
+
+    efi_status (*UsbGetConfigDescriptor) (struct efi_usb_io_protocol* self,
+                                          efi_usb_config_descriptor* descriptor) EFIAPI;
+
+    efi_status (*UsbGetInterfaceDescriptor) (struct efi_usb_io_protocol* self,
+                                             efi_usb_interface_descriptor* descriptor) EFIAPI;
+
+    efi_status (*UsbGetEndpointDescriptor) (struct efi_usb_io_protocol* self,
+                                            uint8_t endpt_index,
+                                            efi_usb_endpoint_descriptor* descriptor) EFIAPI;
+
+    efi_status (*UsbGetStringDescriptor) (struct efi_usb_io_protocol* self,
+                                          uint16_t langid, uint8_t stringid,
+                                          char16_t** str) EFIAPI;
+
+    efi_status (*UsbGetSupportedLanguages) (struct efi_usb_io_protocol* self,
+                                            uint16_t** langid_table,
+                                            uint16_t* table_size) EFIAPI;
+
+    efi_status (*UsbPortReset) (struct efi_usb_io_protocol* self) EFIAPI;
+} efi_usb_io_protocol;
diff --git a/include/efi/runtime-services.h b/include/efi/runtime-services.h
new file mode 100644
index 0000000..613b34f
--- /dev/null
+++ b/include/efi/runtime-services.h
@@ -0,0 +1,151 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <efi/types.h>
+#include <efi/boot-services.h>
+
+#define EFI_RUNTIME_SERVICES_SIGNATURE 0x56524553544e5552
+#define EFI_RUNTIME_SERVICES_REVISION EFI_SPECIFICATION_VERSION
+
+#define EFI_VARIABLE_NON_VOLATILE                          0x00000001
+#define EFI_VARIABLE_BOOTSERVICE_ACCESS                    0x00000002
+#define EFI_VARIABLE_RUNTIME_ACCESS                        0x00000004
+#define EFI_VARIABLE_HARDWARE_ERROR_RECORD                 0x00000008
+#define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS            0x00000010
+#define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS 0x00000020
+#define EFI_VARIABLE_APPEND_WRITE                          0x00000040
+
+// TODO: implement the win_certificate structs if we need them
+//typedef struct {
+//    uint64_t MonotonicCount;
+//    win_certificate_uefi_guid AuthInfo;
+//} efi_variable_authentication;
+//
+//typedef struct {
+//    efi_time TimeStamp;
+//    win_certificate_uefi_guid AuthInfo;
+//} efi_variable_authentication_2;
+
+#define EFI_HARDWARE_ERROR_VARIABLE \
+    {0x414e6bdd, 0xe47b, 0x47cc, {0xb2, 0x44, 0xbb, 0x61, 0x02, 0x0c, 0xf5, 0x16}}
+
+typedef struct {
+    uint16_t Year;
+    uint8_t  Month;
+    uint8_t  Day;
+    uint8_t  Hour;
+    uint8_t  Minute;
+    uint8_t  Second;
+    uint8_t  Pad1;
+    uint32_t Nanosecond;
+    int16_t  TimeZone;
+    uint8_t  Daylight;
+    uint8_t  Pad2;
+} efi_time;
+
+#define EFI_TIME_ADJUST_DAYLIGHT 0x01
+#define EFI_TIME_IN_DAYLIGHT     0x02
+
+#define EFI_UNSPECIFIED_TIMEZONE 0x07FF
+
+typedef struct {
+    uint32_t Resolution;
+    uint32_t Accuracy;
+    bool SetsToZero;
+} efi_time_capabilities;
+
+#define EFI_OPTIONAL_PTR 0x00000001
+
+typedef enum {
+    EfiResetCold,
+    EfiResetWarm,
+    EfiResetShutdown,
+    EfiResetPlatformSpecific
+} efi_reset_type;
+
+typedef struct {
+    uint64_t Length;
+    union {
+        efi_physical_addr DataBlock;
+        efi_physical_addr ContinuationPointer;
+    } Union;
+} efi_capsule_block_descriptor;
+
+typedef struct {
+    efi_guid CapsuleGuid;
+    uint32_t HeaderSize;
+    uint32_t Flags;
+    uint32_t CapsuleImageSize;
+} efi_capsule_header;
+
+#define CAPSULE_FLAGS_PERSIST_ACROSS_RESET  0x00010000
+#define CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE 0x00020000
+#define CAPSULE_FLAGS_INITIATE_RESET        0x00040000
+
+#define EFI_OS_INDICATIONS_BOOT_TO_FW_UI                   0x0000000000000001
+#define EFI_OS_INDICATIONS_TIMESTAMP_REVOCATION            0x0000000000000002
+#define EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED 0x0000000000000004
+#define EFI_OS_INDICATIONS_FMP_CAPSULE_SUPPORTED           0x0000000000000008
+#define EFI_OS_INDICATIONS_CAPSULE_RESULT_VAR_SUPPORTED    0x0000000000000010
+#define EFI_OS_INDICATIONS_START_OS_RECOVERY               0x0000000000000020
+#define EFI_OS_INDICATIONS_START_PLATFORM_RECOVERY         0x0000000000000040
+
+#define EFI_CAPSULE_REPORT_GUID \
+    {0x39b68c46, 0xf7fb, 0x441b, {0xb6, 0xec, 0x16, 0xb0, 0xf6, 0x98, 0x21, 0xf3}}
+
+typedef struct {
+    uint32_t VariableTotalSize;
+    uint32_t Reserved;
+    efi_guid CapsuleGuid;
+    efi_time CapsuleProcessed;
+    efi_status CapsuleStatus;
+} efi_capsule_result_variable_header;
+
+typedef struct {
+    efi_table_header Hdr;
+
+    efi_status (*GetTime) (efi_time* time, efi_time_capabilities* capabilities) EFIAPI;
+
+    efi_status (*SetTime) (efi_time* time) EFIAPI;
+
+    efi_status (*GetWakeupTime) (bool* enabled, bool* pending, efi_time* time) EFIAPI;
+
+    efi_status (*SetWakeupTime) (bool enable, efi_time* time) EFIAPI;
+
+    efi_status (*SetVirtualAddressMap) (size_t memory_map_size, size_t desc_size,
+                                        uint32_t desc_version,
+                                        efi_memory_descriptor* virtual_map) EFIAPI;
+
+    efi_status (*ConvertPointer) (size_t debug_disposition, void** addr) EFIAPI;
+
+    efi_status (*GetVariable) (char16_t* var_name, efi_guid* vendor_guid,
+                               uint32_t* attributes, size_t* data_size, void* data) EFIAPI;
+
+    efi_status (*GetNextVariableName) (size_t* var_name_size, char16_t* var_name,
+                                       efi_guid* vendor_guid) EFIAPI;
+
+    efi_status (*SetVariable) (char16_t* var_name, efi_guid* vendor_guid,
+                               uint32_t attributes, size_t data_size, void* data) EFIAPI;
+
+    efi_status (*GetNextHighMonotonicCount) (uint32_t* high_count) EFIAPI;
+
+    efi_status (*ResetSystem) (efi_reset_type reset_type, efi_status reset_status,
+                               size_t data_size, void* reset_data) EFIAPI;
+
+    efi_status (*UpdateCapsule) (efi_capsule_header** capsule_header_array,
+                                 size_t capsule_count,
+                                 efi_physical_addr scatter_gather_list) EFIAPI;
+
+    efi_status (*QueryCapsuleCapabilities) (efi_capsule_header** capsule_header_array,
+                                            size_t capsule_count,
+                                            uint64_t* max_capsule_size,
+                                            efi_reset_type* reset_type) EFIAPI;
+
+    efi_status (*QueryVariableInfo) (uint32_t attributes,
+                                     uint64_t* max_var_storage_size,
+                                     uint64_t* remaining_var_storage_size,
+                                     uint64_t* max_var_size) EFIAPI;
+} efi_runtime_services;
diff --git a/include/efi/system-table.h b/include/efi/system-table.h
new file mode 100644
index 0000000..3f145af
--- /dev/null
+++ b/include/efi/system-table.h
@@ -0,0 +1,48 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <stdint.h>
+
+#include <efi/types.h>
+#include <efi/boot-services.h>
+#include <efi/runtime-services.h>
+#include <efi/protocol/simple-text-input.h>
+#include <efi/protocol/simple-text-output.h>
+
+#define EFI_SYSTEM_TABLE_SIGNATURE 0x5453595320494249
+#define EFI_2_60_SYSTEM_TABLE_REVISION ((2<<16) | (60))
+#define EFI_2_50_SYSTEM_TABLE_REVISION ((2<<16) | (50))
+#define EFI_2_40_SYSTEM_TABLE_REVISION ((2<<16) | (40))
+#define EFI_2_31_SYSTEM_TABLE_REVISION ((2<<16) | (31))
+#define EFI_2_30_SYSTEM_TABLE_REVISION ((2<<16) | (30))
+#define EFI_2_20_SYSTEM_TABLE_REVISION ((2<<16) | (20))
+#define EFI_2_10_SYSTEM_TABLE_REVISION ((2<<16) | (10))
+#define EFI_2_00_SYSTEM_TABLE_REVISION ((2<<16) | (00))
+#define EFI_1_10_SYSTEM_TABLE_REVISION ((1<<16) | (10))
+#define EFI_1_02_SYSTEM_TABLE_REVISION ((1<<16) | (02))
+#define EFI_SPECIFICATION_VERSION EFI_SYSTEM_TABLE_REVISION
+#define EFI_SYSTEM_TABLE_REVISION EFI_2_60_SYSTEM_TABLE_REVISION
+
+typedef struct {
+    efi_guid VendorGuid;
+    void* VendorTable;
+} efi_configuration_table;
+
+typedef struct efi_system_table {
+    efi_table_header Hdr;
+    char16_t* FirmwareVendor;
+    uint32_t FirmwareRevision;
+    efi_handle ConsoleInHandle;
+    efi_simple_text_input_protocol* ConIn;
+    efi_handle ConsoleOutHandle;
+    efi_simple_text_output_protocol* ConOut;
+    efi_handle StandardErrorHandle;
+    efi_simple_text_output_protocol* StdErr;
+    efi_runtime_services *RuntimeServices;
+    efi_boot_services* BootServices;
+    size_t NumberOfTableEntries;
+    efi_configuration_table *ConfigurationTable;
+} efi_system_table;
diff --git a/include/efi/types.h b/include/efi/types.h
new file mode 100644
index 0000000..2aa6408
--- /dev/null
+++ b/include/efi/types.h
@@ -0,0 +1,141 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <stdint.h>
+
+#define EFIAPI __attribute__((ms_abi))
+
+#define EFI_ERROR_MASK 0x8000000000000000
+#define EFI_ERR(x) (EFI_ERROR_MASK | x)
+#define EFI_ERROR(x) (((int64_t)x) < 0)
+
+#define EFI_SUCCESS              0
+#define EFI_LOAD_ERROR           EFI_ERR(1)
+#define EFI_INVALID_PARAMETER    EFI_ERR(2)
+#define EFI_UNSUPPORTED          EFI_ERR(3)
+#define EFI_BAD_BUFFER_SIZE      EFI_ERR(4)
+#define EFI_BUFFER_TOO_SMALL     EFI_ERR(5)
+#define EFI_NOT_READY            EFI_ERR(6)
+#define EFI_DEVICE_ERROR         EFI_ERR(7)
+#define EFI_WRITE_PROTECTED      EFI_ERR(8)
+#define EFI_OUT_OF_RESOURCES     EFI_ERR(9)
+#define EFI_VOLUME_CORRUPTED     EFI_ERR(10)
+#define EFI_VOLUME_FULL          EFI_ERR(11)
+#define EFI_NO_MEDIA             EFI_ERR(12)
+#define EFI_MEDIA_CHANGED        EFI_ERR(13)
+#define EFI_NOT_FOUND            EFI_ERR(14)
+#define EFI_ACCESS_DENIED        EFI_ERR(15)
+#define EFI_NO_RESPONSE          EFI_ERR(16)
+#define EFI_NO_MAPPING           EFI_ERR(17)
+#define EFI_TIMEOUT              EFI_ERR(18)
+#define EFI_NOT_STARTED          EFI_ERR(19)
+#define EFI_ALREADY_STARTED      EFI_ERR(20)
+#define EFI_ABORTED              EFI_ERR(21)
+#define EFI_ICMP_ERROR           EFI_ERR(22)
+#define EFI_TFTP_ERROR           EFI_ERR(23)
+#define EFI_PROTOCOL_ERROR       EFI_ERR(24)
+#define EFI_INCOMPATIBLE_VERSION EFI_ERR(25)
+#define EFI_SECURITY_VIOLATION   EFI_ERR(26)
+#define EFI_CRC_ERROR            EFI_ERR(27)
+#define EFI_END_OF_MEDIA         EFI_ERR(28)
+#define EFI_END_OF_FILE          EFI_ERR(31)
+#define EFI_INVALID_LANGUAGE     EFI_ERR(32)
+#define EFI_COMPROMISED_DATA     EFI_ERR(33)
+#define EFI_IP_ADDRESS_CONFLICT  EFI_ERR(34)
+#define EFI_HTTP_ERROR           EFI_ERR(35)
+
+// TODO: figure out where to put these. They're just mentioned in passing in the
+// spec as some of many industry standard GUIDs but not part of the spec itself.
+#define ACPI_TABLE_GUID \
+    {0xeb9d2d30, 0x2d88, 0x11d3, {0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d}}
+#define ACPI_20_TABLE_GUID \
+    {0x8868e871, 0xe4f1, 0x11d3, {0xbc, 0x22, 0x00, 0x80, 0xc7, 0x3c, 0x88, 0x81}}
+
+typedef struct {
+    uint64_t Signature;
+    uint32_t Revision;
+    uint32_t HeaderSize;
+    uint32_t CRC32;
+    uint32_t Reserved;
+} efi_table_header;
+
+typedef struct efi_guid {
+    uint32_t data1;
+    uint16_t data2;
+    uint16_t data3;
+    uint8_t data4[8];
+} efi_guid;
+
+typedef void* efi_handle;
+
+typedef size_t efi_status;
+
+typedef struct {
+    uint8_t addr[32];
+} efi_mac_addr;
+
+typedef struct {
+    uint8_t addr[4];
+} efi_ipv4_addr;
+
+typedef struct {
+    uint8_t addr[16];
+} efi_ipv6_addr;
+
+typedef union {
+    efi_ipv4_addr v4;
+    efi_ipv6_addr v6;
+} efi_ip_addr;
+
+// This really belongs in boot-services.h, but causes circular dependencies with
+// device-path.h.
+typedef enum {
+    EfiReservedMemoryType,
+    EfiLoaderCode,
+    EfiLoaderData,
+    EfiBootServicesCode,
+    EfiBootServicesData,
+    EfiRuntimeServicesCode,
+    EfiRuntimeServicesData,
+    EfiConventionalMemory,
+    EfiUnusableMemory,
+    EfiACPIReclaimMemory,
+    EfiACPIMemoryNVS,
+    EfiMemoryMappedIO,
+    EfiMemoryMappedIOPortSpace,
+    EfiPalCode,
+    EfiPersistentMemory,
+    EfiMaxMemoryType
+} efi_memory_type;
+
+typedef uint64_t efi_physical_addr;
+typedef uint64_t efi_virtual_addr;
+
+typedef void* efi_event;
+
+#define EVT_TIMER                         0x80000000
+#define EVT_RUNTIME                       0x40000000
+#define EVT_NOTIFY_WAIT                   0x00000100
+#define EVT_NOTIFY_SIGNAL                 0x00000200
+#define EVT_SIGNAL_EXIT_BOOT_SERVICES     0x00000201
+#define EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE 0x60000202
+
+#define EFI_EVENT_GROUP_EXIT_BOOT_SERVICES \
+    {0x27abf055, 0xb1b8, 0x4c26, {0x80, 0x48, 0x74, 0x8f, 0x37, 0xba, 0xa2, 0xdf}}
+#define EFI_EVENT_GROUP_VIRTUAL_ADDRESS_CHANGE \
+    {0x13fa7698, 0xc831, 0x49c7, {0x87, 0xea, 0x8f, 0x43, 0xfc, 0xc2, 0x51, 0x96}}
+#define EFI_EVENT_GROUP_MEMORY_MAP_CHANGE \
+    {0x78bee926, 0x692f, 0x48fd, {0x9e, 0xdb, 0x01, 0x42, 0x2e, 0xf0, 0xd7, 0xab}}
+#define EFI_EVENT_GROUP_READY_TO_BOOT \
+    {0x7ce88fb3, 0x4bd7, 0x4679, {0x87, 0xa8, 0xa8, 0xd8, 0xde, 0xe5, 0x0d, 0x2b}}
+
+typedef void (*efi_event_notify) (efi_event event, void* ctx) EFIAPI;
+
+typedef enum {
+    TimerCancel,
+    TimerPeriodic,
+    TimerRelative
+} efi_timer_delay;
diff --git a/include/stdint.h b/include/stdint.h
index 6dd18fd..a7e4d5a 100644
--- a/include/stdint.h
+++ b/include/stdint.h
@@ -29,4 +29,4 @@
 #define INT_MAX (__INT_MAX__)
 
 typedef int ssize_t;
-
+typedef __CHAR16_TYPE__ char16_t;
diff --git a/include/utils.h b/include/utils.h
index 3a7b225..76f96ff 100644
--- a/include/utils.h
+++ b/include/utils.h
@@ -4,30 +4,40 @@
 
 #pragma once
 
-void InitGoodies(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys);
+#include <efi/boot-services.h>
+#include <efi/system-table.h>
+#include <efi/types.h>
+#include <efi/protocol/device-path.h>
+#include <efi/protocol/simple-text-output.h>
+
+void InitGoodies(efi_handle img, efi_system_table* sys);
 
 void WaitAnyKey(void);
-void Fatal(const char* msg, EFI_STATUS status);
-CHAR16* HandleToString(EFI_HANDLE handle);
-const char *efi_strerror(EFI_STATUS status);
-const CHAR16 *efi_wstrerror(EFI_STATUS status);
-size_t strlen_16(CHAR16 *str);
+void Fatal(const char* msg, efi_status status);
+char16_t* HandleToString(efi_handle handle);
+const char *efi_strerror(efi_status status);
+const char16_t* efi_wstrerror(efi_status status);
+size_t strlen_16(char16_t* str);
+
+char16_t* DevicePathToStr(efi_device_path_protocol* path);
+
+int CompareGuid(efi_guid* guid1, efi_guid* guid2);
 
 // Convenience wrappers for Open/Close protocol for use by
 // UEFI app code that's not a driver model participant
-EFI_STATUS OpenProtocol(EFI_HANDLE h, EFI_GUID* guid, void** ifc);
-EFI_STATUS CloseProtocol(EFI_HANDLE h, EFI_GUID* guid);
+efi_status OpenProtocol(efi_handle h, efi_guid* guid, void** ifc);
+efi_status CloseProtocol(efi_handle h, efi_guid* guid);
 
-void* LoadFile(CHAR16* filename, UINTN* size_out);
+void* LoadFile(char16_t* filename, size_t* size_out);
 
-EFI_STATUS FindPCIMMIO(EFI_BOOT_SERVICES* bs, uint8_t cls, uint8_t sub, uint8_t ifc, uint64_t* mmio);
+efi_status FindPCIMMIO(efi_boot_services* bs, uint8_t cls, uint8_t sub, uint8_t ifc, uint64_t* mmio);
 
 // GUIDs
-extern EFI_GUID SimpleFileSystemProtocol;
-extern EFI_GUID FileInfoGUID;
+extern efi_guid SimpleFileSystemProtocol;
+extern efi_guid FileInfoGUID;
 
 // Global Context
-extern EFI_HANDLE gImg;
-extern EFI_SYSTEM_TABLE* gSys;
-extern EFI_BOOT_SERVICES* gBS;
-extern SIMPLE_TEXT_OUTPUT_INTERFACE* gConOut;
+extern efi_handle gImg;
+extern efi_system_table* gSys;
+extern efi_boot_services* gBS;
+extern efi_simple_text_output_protocol* gConOut;
diff --git a/lib/console-printf.c b/lib/console-printf.c
index 3a07f67..e599cae 100644
--- a/lib/console-printf.c
+++ b/lib/console-printf.c
@@ -3,9 +3,6 @@
 // found in the LICENSE file.
 
 #include <printf.h>
-
-#include <efi.h>
-#include <efilib.h>
 #include <utils.h>
 
 #define PCBUFMAX 126
@@ -14,12 +11,12 @@
 
 typedef struct {
     int off;
-    CHAR16 buf[PCBUFMAX + 2];
+    char16_t buf[PCBUFMAX + 2];
 } _pcstate;
 
 static int _printf_console_out(const char* str, size_t len, void* _state) {
     _pcstate* state = _state;
-    CHAR16* buf = state->buf;
+    char16_t* buf = state->buf;
     int i = state->off;
     int n = len;
     while (n > 0) {
diff --git a/lib/efi/guids.c b/lib/efi/guids.c
new file mode 100644
index 0000000..20fd51a
--- /dev/null
+++ b/lib/efi/guids.c
@@ -0,0 +1,32 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <efi/protocol/device-path.h>
+#include <efi/protocol/device-path-to-text.h>
+#include <efi/protocol/driver-binding.h>
+#include <efi/protocol/file.h>
+#include <efi/protocol/graphics-output.h>
+#include <efi/protocol/loaded-image.h>
+#include <efi/protocol/managed-network.h>
+#include <efi/protocol/pci-root-bridge-io.h>
+#include <efi/protocol/simple-file-system.h>
+#include <efi/protocol/simple-network.h>
+#include <efi/protocol/simple-text-input.h>
+#include <efi/protocol/simple-text-output.h>
+#include <efi/protocol/usb-io.h>
+
+efi_guid DevicePathProtocol = EFI_DEVICE_PATH_PROTOCOL_GUID;
+efi_guid DevicePathToTextProtocol = EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID;
+efi_guid DriverBindingProtocol = EFI_DRIVER_BINDING_PROTOCOL_GUID;
+efi_guid FileInfoGuid = EFI_FILE_INFO_GUID;
+efi_guid FileSystemInfoGuid = EFI_FILE_SYSTEM_INFO_GUID;
+efi_guid GraphicsOutputProtocol = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
+efi_guid LoadedImageProtocol = EFI_LOADED_IMAGE_PROTOCOL_GUID;
+efi_guid ManagedNetworkProtocol = EFI_MANAGED_NETWORK_PROTOCOL_GUID;
+efi_guid PciRootBridgeIoProtocol = EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID;
+efi_guid SimpleFileSystemProtocol = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;
+efi_guid SimpleNetworkProtocol = EFI_SIMPLE_NETWORK_PROTOCOL_GUID;
+efi_guid SimpleTextInputProtocol = EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID;
+efi_guid SimpleTextOutputProtocol = EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID;
+efi_guid UsbIoProtocol = EFI_USB_IO_PROTOCOL_GUID;
diff --git a/lib/loadfile.c b/lib/loadfile.c
index aad14ea..bbe5410 100644
--- a/lib/loadfile.c
+++ b/lib/loadfile.c
@@ -2,16 +2,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <efi.h>
-#include <efilib.h>
+#include <efi/protocol/loaded-image.h>
+#include <efi/protocol/simple-file-system.h>
+
 #include <utils.h>
 #include <stdio.h>
 
-void* LoadFile(CHAR16* filename, UINTN* _sz) {
-    EFI_LOADED_IMAGE* loaded;
-    EFI_STATUS r;
+void* LoadFile(char16_t* filename, size_t* _sz) {
+    efi_loaded_image_protocol* loaded;
+    efi_status r;
     void* data = NULL;
-    UINTN pages = 0;
+    size_t pages = 0;
 
     r = OpenProtocol(gImg, &LoadedImageProtocol, (void**)&loaded);
     if (r) {
@@ -25,21 +26,21 @@
 	printf("Img Base=%lx Size=%lx\n", loaded->ImageBase, loaded->ImageSize);
 #endif
 
-    EFI_FILE_IO_INTERFACE* fioi;
-    r = OpenProtocol(loaded->DeviceHandle, &SimpleFileSystemProtocol, (void**)&fioi);
+    efi_simple_file_system_protocol* sfs;
+    r = OpenProtocol(loaded->DeviceHandle, &SimpleFileSystemProtocol, (void**)&sfs);
     if (r) {
         printf("LoadFile: Cannot open SimpleFileSystemProtocol (%s)\n", efi_strerror(r));
         goto exit1;
     }
 
-    EFI_FILE_HANDLE root;
-    r = fioi->OpenVolume(fioi, &root);
+    efi_file_protocol* root;
+    r = sfs->OpenVolume(sfs, &root);
     if (r) {
         printf("LoadFile: Cannot open root volume (%s)\n", efi_strerror(r));
         goto exit2;
     }
 
-    EFI_FILE_HANDLE file;
+    efi_file_protocol* file;
     r = root->Open(root, &file, filename, EFI_FILE_MODE_READ, 0);
     if (r) {
         printf("LoadFile: Cannot open file (%s)\n", efi_strerror(r));
@@ -47,16 +48,16 @@
     }
 
     char buf[512];
-    UINTN sz = sizeof(buf);
-    EFI_FILE_INFO* finfo = (void*)buf;
-    r = file->GetInfo(file, &FileInfoGUID, &sz, finfo);
+    size_t sz = sizeof(buf);
+    efi_file_info* finfo = (void*)buf;
+    r = file->GetInfo(file, &FileInfoGuid, &sz, finfo);
     if (r) {
         printf("LoadFile: Cannot get FileInfo (%s)\n", efi_strerror(r));
         goto exit3;
     }
 
     pages = (finfo->FileSize + 4095) / 4096;
-    r = gBS->AllocatePages(AllocateAnyPages, EfiLoaderData, pages, (EFI_PHYSICAL_ADDRESS *)&data);
+    r = gBS->AllocatePages(AllocateAnyPages, EfiLoaderData, pages, (efi_physical_addr *)&data);
     if (r) {
         printf("LoadFile: Cannot allocate buffer (%s)\n", efi_strerror(r));
         data = NULL;
@@ -67,13 +68,13 @@
     r = file->Read(file, &sz, data);
     if (r) {
         printf("LoadFile: Error reading file (%s)\n", efi_strerror(r));
-        gBS->FreePages((EFI_PHYSICAL_ADDRESS)data, pages);
+        gBS->FreePages((efi_physical_addr)data, pages);
         data = NULL;
         goto exit4;
     }
     if (sz != finfo->FileSize) {
         printf("LoadFile: Short read\n");
-        gBS->FreePages((EFI_PHYSICAL_ADDRESS)data, pages);
+        gBS->FreePages((efi_physical_addr)data, pages);
         data = NULL;
         goto exit4;
     }
diff --git a/lib/utils.c b/lib/utils.c
index 67107cb..4dc2cd8 100644
--- a/lib/utils.c
+++ b/lib/utils.c
@@ -2,16 +2,20 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <efi.h>
-#include <efilib.h>
+#include <efi/types.h>
+#include <efi/protocol/device-path-to-text.h>
+#include <efi/protocol/file.h>
+#include <efi/protocol/simple-file-system.h>
 
-#include <utils.h>
+#include <stdlib.h>
+#include <string.h>
 #include <printf.h>
+#include <utils.h>
 
 #define ERR_ENTRY(x) { #x, L"" #x }
 typedef struct {
-    const char *str;
-    const CHAR16 *w_str;
+    const char* str;
+    const char16_t* w_str;
 } err_entry_t;
 
 err_entry_t efi_error_labels[] = {
@@ -49,18 +53,12 @@
     ERR_ENTRY(EFI_COMPROMISED_DATA),
 };
 
-// Useful GUID Constants Not Defined by -lefi
-EFI_GUID SimpleFileSystemProtocol = SIMPLE_FILE_SYSTEM_PROTOCOL;
-EFI_GUID FileInfoGUID = EFI_FILE_INFO_ID;
+efi_system_table* gSys;
+efi_handle gImg;
+efi_boot_services* gBS;
+efi_simple_text_output_protocol* gConOut;
 
-// -lefi has its own globals, but this may end up not
-// depending on that, so let's not depend on those
-EFI_SYSTEM_TABLE* gSys;
-EFI_HANDLE gImg;
-EFI_BOOT_SERVICES* gBS;
-SIMPLE_TEXT_OUTPUT_INTERFACE* gConOut;
-
-void InitGoodies(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys) {
+void InitGoodies(efi_handle img, efi_system_table* sys) {
     gSys = sys;
     gImg = img;
     gBS = sys->BootServices;
@@ -68,38 +66,66 @@
 }
 
 void WaitAnyKey(void) {
-    SIMPLE_INPUT_INTERFACE* sii = gSys->ConIn;
-    EFI_INPUT_KEY key;
+    efi_simple_text_input_protocol* sii = gSys->ConIn;
+    efi_input_key key;
     while (sii->ReadKeyStroke(sii, &key) != EFI_SUCCESS)
         ;
 }
 
-void Fatal(const char* msg, EFI_STATUS status) {
+void Fatal(const char* msg, efi_status status) {
     printf("\nERROR: %s (%s)\n", msg, efi_strerror(status));
     WaitAnyKey();
     gBS->Exit(gImg, 1, 0, NULL);
 }
 
-CHAR16* HandleToString(EFI_HANDLE h) {
-    EFI_DEVICE_PATH* path = DevicePathFromHandle(h);
-    if (path == NULL)
-        return L"<NoPath>";
-    CHAR16* str = DevicePathToStr(path);
-    if (str == NULL)
-        return L"<NoString>";
+char16_t* DevicePathToStr(efi_device_path_protocol* path) {
+    efi_device_path_to_text_protocol* prot;
+    efi_status status = gBS->LocateProtocol(&DevicePathToTextProtocol, NULL, (void**)&prot);
+    if (EFI_ERROR(status)) {
+        return NULL;
+    }
+    return prot->ConvertDevicePathToText(path, false, false);
+}
+
+int CompareGuid(efi_guid* guid1, efi_guid* guid2) {
+    return memcmp(guid1, guid2, sizeof(efi_guid));
+}
+
+char16_t* HandleToString(efi_handle h) {
+    efi_device_path_protocol* path;
+    efi_status status = gBS->HandleProtocol(h, &DevicePathProtocol, (void*)&path);
+    if (EFI_ERROR(status)) {
+        char16_t* err;
+        status = gBS->AllocatePool(EfiLoaderData, sizeof(L"<NoPath>"), (void**)&err);
+        if (EFI_ERROR(status)) {
+            return NULL;
+        }
+        gBS->CopyMem(err, L"<NoPath>", sizeof(L"<NoPath>"));
+        return err;
+    }
+    char16_t* str = DevicePathToStr(path);
+    if (str == NULL) {
+        char16_t* err;
+        status = gBS->AllocatePool(EfiLoaderData, sizeof(L"<NoString>"), (void**)&err);
+        if (EFI_ERROR(status)) {
+            return NULL;
+        }
+        gBS->CopyMem(err, L"<NoString>", sizeof(L"<NoString>"));
+        return err;
+    }
     return str;
 }
 
-EFI_STATUS OpenProtocol(EFI_HANDLE h, EFI_GUID* guid, void** ifc) {
+efi_status OpenProtocol(efi_handle h, efi_guid* guid, void** ifc) {
     return gBS->OpenProtocol(h, guid, ifc, gImg, NULL,
                              EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
 }
 
-EFI_STATUS CloseProtocol(EFI_HANDLE h, EFI_GUID* guid) {
+efi_status CloseProtocol(efi_handle h, efi_guid* guid) {
     return gBS->CloseProtocol(h, guid, gImg, NULL);
 }
 
-const char *efi_strerror(EFI_STATUS status)
+const char *efi_strerror(efi_status status)
 {
     size_t i = (~EFI_ERROR_MASK & status);
     if (i < sizeof(efi_error_labels)/sizeof(efi_error_labels[0])) {
@@ -109,7 +135,7 @@
     return "<Unknown error>";
 }
 
-const CHAR16 *efi_wstrerror(EFI_STATUS status)
+const char16_t* efi_wstrerror(efi_status status)
 {
     size_t i = (~EFI_ERROR_MASK & status);
     if (i < sizeof(efi_error_labels)/sizeof(efi_error_labels[0])) {
@@ -119,7 +145,7 @@
     return L"<Unknown error>";
 }
 
-size_t strlen_16(CHAR16 *str)
+size_t strlen_16(char16_t* str)
 {
     size_t len = 0;
     while (*(str + len) != '\0') {
diff --git a/src/fileio.c b/src/fileio.c
index 2cad9da..3e39970 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -2,48 +2,51 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <efi.h>
-#include <efilib.h>
+#include <efi/system-table.h>
+#include <efi/types.h>
+#include <efi/protocol/loaded-image.h>
+#include <efi/protocol/simple-file-system.h>
+
+#include <stdio.h>
 #include <utils.h>
 
-EFI_STATUS efi_main(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys) {
-    EFI_LOADED_IMAGE* loaded;
-    EFI_STATUS r;
+efi_status efi_main(efi_handle img, efi_system_table* sys) {
+    efi_loaded_image_protocol* loaded;
+    efi_status r;
 
-    InitializeLib(img, sys);
     InitGoodies(img, sys);
 
-    Print(L"Hello, EFI World\n");
+    printf("Hello, EFI World\n");
 
     r = OpenProtocol(img, &LoadedImageProtocol, (void**)&loaded);
     if (r)
         Fatal("LoadedImageProtocol", r);
 
-    Print(L"Img DeviceHandle='%s'\n", HandleToString(loaded->DeviceHandle));
-    Print(L"Img FilePath='%s'\n", DevicePathToStr(loaded->FilePath));
-    Print(L"Img Base=%lx Size=%lx\n", loaded->ImageBase, loaded->ImageSize);
+    printf("Img DeviceHandle='%ls'\n", HandleToString(loaded->DeviceHandle));
+    printf("Img FilePath='%ls'\n", DevicePathToStr(loaded->FilePath));
+    printf("Img Base=%p Size=%lx\n", loaded->ImageBase, loaded->ImageSize);
 
-    EFI_FILE_IO_INTERFACE* fioi;
-    r = OpenProtocol(loaded->DeviceHandle, &SimpleFileSystemProtocol, (void**)&fioi);
+    efi_simple_file_system_protocol* sfs;
+    r = OpenProtocol(loaded->DeviceHandle, &SimpleFileSystemProtocol, (void**)&sfs);
     if (r)
         Fatal("SimpleFileSystemProtocol", r);
 
-    EFI_FILE_HANDLE root;
-    r = fioi->OpenVolume(fioi, &root);
+    efi_file_protocol* root;
+    r = sfs->OpenVolume(sfs, &root);
     if (r)
         Fatal("OpenVolume", r);
 
-    EFI_FILE_HANDLE file;
+    efi_file_protocol* file;
     r = root->Open(root, &file, L"README.txt", EFI_FILE_MODE_READ, 0);
 
     if (r == EFI_SUCCESS) {
         char buf[512];
-        UINTN sz = sizeof(buf);
-        EFI_FILE_INFO* finfo = (void*)buf;
-        r = file->GetInfo(file, &FileInfoGUID, &sz, finfo);
+        size_t sz = sizeof(buf);
+        efi_file_info* finfo = (void*)buf;
+        r = file->GetInfo(file, &FileInfoGuid, &sz, finfo);
         if (r)
             Fatal("GetInfo", r);
-        Print(L"FileSize %ld\n", finfo->FileSize);
+        printf("FileSize %ld\n", finfo->FileSize);
 
         sz = sizeof(buf) - 1;
         r = file->Read(file, &sz, buf);
@@ -52,7 +55,7 @@
 
         char* x = buf;
         while (sz-- > 0)
-            Print(L"%c", (CHAR16)*x++);
+            printf("%c", *x++);
 
         file->Close(file);
     }
diff --git a/src/hello.c b/src/hello.c
index 551e354..45c62bb 100644
--- a/src/hello.c
+++ b/src/hello.c
@@ -2,10 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <efi.h>
+#include <efi/types.h>
 
-EFI_STATUS efi_main(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys) {
-    SIMPLE_TEXT_OUTPUT_INTERFACE* ConOut = sys->ConOut;
+efi_status efi_main(efi_handle img, efi_system_table* sys) {
+    efi_simple_text_output_protocol* ConOut = sys->ConOut;
     ConOut->OutputString(ConOut, L"Hello, EFI World!\r\n");
     return EFI_SUCCESS;
 }
diff --git a/src/magenta.c b/src/magenta.c
index 5d7dfa4..e4e1b0a 100644
--- a/src/magenta.c
+++ b/src/magenta.c
@@ -4,18 +4,18 @@
 
 #include <magenta.h>
 
-#include <efilib.h>
+#include <efi/protocol/graphics-output.h>
+
 #include <stdio.h>
 #include <string.h>
 #include <utils.h>
 
-static EFI_GUID GraphicsOutputProtocol = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
-static EFI_GUID AcpiTableGUID = ACPI_TABLE_GUID;
-static EFI_GUID Acpi2TableGUID = ACPI_20_TABLE_GUID;
-static UINT8 ACPI_RSD_PTR[8] = "RSD PTR ";
+static efi_guid AcpiTableGUID = ACPI_TABLE_GUID;
+static efi_guid Acpi2TableGUID = ACPI_20_TABLE_GUID;
+static uint8_t ACPI_RSD_PTR[8] = "RSD PTR ";
 
-uint32_t find_acpi_root(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys) {
-    EFI_CONFIGURATION_TABLE* cfgtab = sys->ConfigurationTable;
+uint32_t find_acpi_root(efi_handle img, efi_system_table* sys) {
+    efi_configuration_table* cfgtab = sys->ConfigurationTable;
     int i;
 
     for (i = 0; i < sys->NumberOfTableEntries; i++) {
@@ -24,7 +24,7 @@
             // not an ACPI table
             continue;
         }
-        if (CompareMem(cfgtab[i].VendorTable, ACPI_RSD_PTR, 8)) {
+        if (memcmp(cfgtab[i].VendorTable, ACPI_RSD_PTR, 8)) {
             // not the Root Description Pointer
             continue;
         }
@@ -50,9 +50,9 @@
 };
 
 struct e820entry {
-    UINT64 addr;
-    UINT64 size;
-    UINT32 type;
+    uint64_t addr;
+    uint64_t size;
+    uint32_t type;
 } __attribute__((packed));
 
 static unsigned e820type(unsigned uefi_mem_type) {
@@ -91,17 +91,17 @@
 static unsigned char scratch[32768];
 static struct e820entry e820table[128];
 
-static int process_memory_map(EFI_SYSTEM_TABLE* sys, UINTN* _key, int silent) {
-    EFI_MEMORY_DESCRIPTOR* mmap;
+static int process_memory_map(efi_system_table* sys, size_t* _key, int silent) {
+    efi_memory_descriptor* mmap;
     struct e820entry* entry = e820table;
-    UINTN msize, off;
-    UINTN mkey, dsize;
-    UINT32 dversion;
+    size_t msize, off;
+    size_t mkey, dsize;
+    uint32_t dversion;
     unsigned n, type;
-    EFI_STATUS r;
+    efi_status r;
 
     msize = sizeof(scratch);
-    mmap = (EFI_MEMORY_DESCRIPTOR*)scratch;
+    mmap = (efi_memory_descriptor*)scratch;
     mkey = dsize = dversion = 0;
     r = sys->BootServices->GetMemoryMap(&msize, mmap, &mkey, &dsize, &dversion);
     if (!silent)
@@ -115,7 +115,7 @@
         return -1;
     }
     for (off = 0, n = 0; off < msize; off += dsize) {
-        mmap = (EFI_MEMORY_DESCRIPTOR*)(scratch + off);
+        mmap = (efi_memory_descriptor*)(scratch + off);
         type = e820type(mmap->Type);
         if (type == E820_IGNORE) {
             continue;
@@ -166,9 +166,9 @@
 
 #define ZP_MAGIC_VALUE 0xDBC64323
 
-#define ZP8(p, off) (*((UINT8*)((p) + (off))))
-#define ZP16(p, off) (*((UINT16*)((p) + (off))))
-#define ZP32(p, off) (*((UINT32*)((p) + (off))))
+#define ZP8(p, off) (*((uint8_t*)((p) + (off))))
+#define ZP16(p, off) (*((uint16_t*)((p) + (off))))
+#define ZP32(p, off) (*((uint32_t*)((p) + (off))))
 
 static void install_memmap(kernel_t* k, struct e820entry* memmap, unsigned count) {
     memcpy(k->zeropage + ZP_E820_TABLE, memmap, sizeof(*memmap) * count);
@@ -177,7 +177,7 @@
 
 static void start_kernel(kernel_t* k) {
     // 64bit entry is at offset 0x200
-    UINT64 entry = (UINT64)(k->image + 0x200);
+    uint64_t entry = (uint64_t)(k->image + 0x200);
 
     // ebx = 0, ebp = 0, edi = 0, esi = zeropage
     __asm__ __volatile__(
@@ -190,11 +190,11 @@
         ;
 }
 
-static int load_kernel(EFI_BOOT_SERVICES* bs, uint8_t* image, size_t sz, kernel_t* k) {
-    UINT32 setup_sz;
-    UINT32 image_sz;
-    UINT32 setup_end;
-    EFI_PHYSICAL_ADDRESS mem;
+static int load_kernel(efi_boot_services* bs, uint8_t* image, size_t sz, kernel_t* k) {
+    uint32_t setup_sz;
+    uint32_t image_sz;
+    uint32_t setup_end;
+    efi_physical_addr mem;
 
     k->zeropage = NULL;
     k->cmdline = NULL;
@@ -248,10 +248,10 @@
     k->image = (void*)mem;
 
     // setup zero page, copy setup header from kernel binary
-    ZeroMem(k->zeropage, 4096);
-    CopyMem(k->zeropage + ZP_SETUP, image + ZP_SETUP, setup_end - ZP_SETUP);
+    memset(k->zeropage, 0, 4096);
+    memcpy(k->zeropage + ZP_SETUP, image + ZP_SETUP, setup_end - ZP_SETUP);
 
-    CopyMem(k->image, image + setup_sz, image_sz);
+    memcpy(k->image, image + setup_sz, image_sz);
 
     // empty commandline for now
     ZP32(k->zeropage, ZP_CMDLINE) = (uint64_t)k->cmdline;
@@ -270,28 +270,28 @@
     return 0;
 fail:
     if (k->image) {
-        bs->FreePages((EFI_PHYSICAL_ADDRESS)k->image, k->pages);
+        bs->FreePages((efi_physical_addr)k->image, k->pages);
     }
     if (k->cmdline) {
-        bs->FreePages((EFI_PHYSICAL_ADDRESS)k->cmdline, 1);
+        bs->FreePages((efi_physical_addr)k->cmdline, 1);
     }
     if (k->zeropage) {
-        bs->FreePages((EFI_PHYSICAL_ADDRESS)k->zeropage, 1);
+        bs->FreePages((efi_physical_addr)k->zeropage, 1);
     }
 
     return -1;
 }
 
-int boot_kernel(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys,
+int boot_kernel(efi_handle img, efi_system_table* sys,
                 void* image, size_t sz, void* ramdisk, size_t rsz,
                 void* cmdline, size_t csz, void* cmdline2, size_t csz2) {
-    EFI_BOOT_SERVICES* bs = sys->BootServices;
+    efi_boot_services* bs = sys->BootServices;
     kernel_t kernel;
-    EFI_STATUS r;
-    UINTN key;
+    efi_status r;
+    size_t key;
     int n, i;
 
-    EFI_GRAPHICS_OUTPUT_PROTOCOL* gop;
+    efi_graphics_output_protocol* gop;
     bs->LocateProtocol(&GraphicsOutputProtocol, NULL, (void**)&gop);
 
     printf("boot_kernel() from %p (%ld bytes)\n", image, sz);
@@ -307,10 +307,10 @@
     ZP32(kernel.zeropage, ZP_EXTRA_MAGIC) = ZP_MAGIC_VALUE;
     ZP32(kernel.zeropage, ZP_ACPI_RSD) = find_acpi_root(img, sys);
 
-    ZP32(kernel.zeropage, ZP_FB_BASE) = (UINT32)gop->Mode->FrameBufferBase;
-    ZP32(kernel.zeropage, ZP_FB_WIDTH) = (UINT32)gop->Mode->Info->HorizontalResolution;
-    ZP32(kernel.zeropage, ZP_FB_HEIGHT) = (UINT32)gop->Mode->Info->VerticalResolution;
-    ZP32(kernel.zeropage, ZP_FB_STRIDE) = (UINT32)gop->Mode->Info->PixelsPerScanLine;
+    ZP32(kernel.zeropage, ZP_FB_BASE) = (uint32_t)gop->Mode->FrameBufferBase;
+    ZP32(kernel.zeropage, ZP_FB_WIDTH) = (uint32_t)gop->Mode->Info->HorizontalResolution;
+    ZP32(kernel.zeropage, ZP_FB_HEIGHT) = (uint32_t)gop->Mode->Info->VerticalResolution;
+    ZP32(kernel.zeropage, ZP_FB_STRIDE) = (uint32_t)gop->Mode->Info->PixelsPerScanLine;
     ZP32(kernel.zeropage, ZP_FB_FORMAT) = 5; // XRGB32
     ZP32(kernel.zeropage, ZP_FB_REGBASE) = 0;
     ZP32(kernel.zeropage, ZP_FB_SIZE) = 256 * 1024 * 1024;
diff --git a/src/magenta.h b/src/magenta.h
index c3ae7db..1c92213 100644
--- a/src/magenta.h
+++ b/src/magenta.h
@@ -2,15 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <efi.h>
+#include <efi/types.h>
+#include <efi/system-table.h>
 
 typedef struct {
-    UINT8* zeropage;
-    UINT8* cmdline;
+    uint8_t* zeropage;
+    uint8_t* cmdline;
     void* image;
-    UINT32 pages;
+    uint32_t pages;
 } kernel_t;
 
-int boot_kernel(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys,
+int boot_kernel(efi_handle img, efi_system_table* sys,
                 void* image, size_t sz, void* ramdisk, size_t rsz,
                 void* cmdline, size_t csz, void* cmdline2, size_t csz2);
diff --git a/src/netifc.c b/src/netifc.c
index d5a4797..749682c 100644
--- a/src/netifc.c
+++ b/src/netifc.c
@@ -2,8 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <efi.h>
-#include <efilib.h>
+#include <efi/protocol/simple-network.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -12,10 +11,10 @@
 #include <inet6.h>
 #include <netifc.h>
 
-static EFI_SIMPLE_NETWORK* snp;
+static efi_simple_network_protocol* snp;
 
 #define MAX_FILTER 8
-static EFI_MAC_ADDRESS mcast_filters[MAX_FILTER];
+static efi_mac_addr mcast_filters[MAX_FILTER];
 static unsigned mcast_filter_count = 0;
 
 #define NUM_BUFFER_PAGES 8
@@ -30,7 +29,7 @@
     uint8_t data[0];
 };
 
-static EFI_PHYSICAL_ADDRESS eth_buffers_base = 0;
+static efi_physical_addr eth_buffers_base = 0;
 static eth_buffer* eth_buffers = NULL;
 
 void* eth_get_buffer(size_t sz) {
@@ -60,7 +59,7 @@
 }
 
 int eth_send(void* data, size_t len) {
-    EFI_STATUS r;
+    efi_status r;
 
     if ((r = snp->Transmit(snp, 0, len, (void*)data, NULL, NULL, NULL))) {
         eth_put_buffer(data);
@@ -77,7 +76,7 @@
     printf("RcvMask/RcvCfg/MaxMcast/NumMcast %d %d %d %d\n",
            snp->Mode->ReceiveFilterMask, snp->Mode->ReceiveFilterSetting,
            snp->Mode->MaxMCastFilterCount, snp->Mode->MCastFilterCount);
-    UINT8* x = snp->Mode->CurrentAddress.Addr;
+    uint8_t* x = snp->Mode->CurrentAddress.addr;
     printf("MacAddr %02x:%02x:%02x:%02x:%02x:%02x\n",
            x[0], x[1], x[2], x[3], x[4], x[5]);
     printf("SetMac/MultiTx/LinkDetect/Link %d %d %d %d\n",
@@ -95,7 +94,7 @@
     return 0;
 }
 
-static EFI_EVENT net_timer = NULL;
+static efi_event net_timer = NULL;
 
 #define TIMER_MS(n) (((uint64_t)(n)) * 10000UL)
 
@@ -118,12 +117,12 @@
 
 /* Search the available network interfaces via SimpleNetworkProtocol handles
  * and find the first valid one with a Link detected */
-EFI_SIMPLE_NETWORK *netifc_find_available(void) {
-    EFI_BOOT_SERVICES* bs = gSys->BootServices;
-    EFI_STATUS ret;
-    EFI_SIMPLE_NETWORK *cur_snp = NULL;
-    EFI_HANDLE handles[32];
-    CHAR16 *paths[32];
+efi_simple_network_protocol* netifc_find_available(void) {
+    efi_boot_services* bs = gSys->BootServices;
+    efi_status ret;
+    efi_simple_network_protocol* cur_snp = NULL;
+    efi_handle handles[32];
+    char16_t *paths[32];
     size_t nic_cnt = 0;
     size_t sz = sizeof(handles);
     uint32_t last_parent = 0;
@@ -137,7 +136,7 @@
         return NULL;
     }
 
-    nic_cnt = sz / sizeof(EFI_HANDLE);
+    nic_cnt = sz / sizeof(efi_handle);
     for (size_t i = 0; i < nic_cnt; i++) {
         paths[i] = HandleToString(handles[i]);
     }
@@ -155,7 +154,7 @@
             }
         }
 
-        Print(L"%s: ", paths[i]);
+        printf("%ls: ", paths[i]);
         ret = bs->HandleProtocol(handles[i], &SimpleNetworkProtocol, (void**)&cur_snp);
         if (ret) {
             printf("Failed to open (%s)\n", efi_strerror(ret));
@@ -205,8 +204,8 @@
 }
 
 int netifc_open(void) {
-    EFI_BOOT_SERVICES* bs = gSys->BootServices;
-    EFI_STATUS ret;
+    efi_boot_services* bs = gSys->BootServices;
+    efi_status ret;
     int j;
 
     bs->CreateEvent(EVT_TIMER, TPL_CALLBACK, NULL, NULL, &net_timer);
@@ -230,7 +229,7 @@
         ptr += 2048;
     }
 
-    ip6_init(snp->Mode->CurrentAddress.Addr);
+    ip6_init(snp->Mode->CurrentAddress.addr);
 
     ret = snp->ReceiveFilters(snp,
                             EFI_SIMPLE_NETWORK_RECEIVE_UNICAST |
@@ -290,11 +289,11 @@
 }
 
 void netifc_poll(void) {
-    UINT8 data[1514];
-    EFI_STATUS r;
-    UINTN hsz, bsz;
-    UINT32 irq;
-    VOID* txdone;
+    uint8_t data[1514];
+    efi_status r;
+    size_t hsz, bsz;
+    uint32_t irq;
+    void* txdone;
 
     if ((r = snp->GetStatus(snp, &irq, &txdone))) {
         return;
diff --git a/src/osboot.c b/src/osboot.c
index 193c5ee..5811276 100644
--- a/src/osboot.c
+++ b/src/osboot.c
@@ -2,19 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <efi.h>
-#include <efilib.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include <efi/boot-services.h>
+#include <efi/system-table.h>
+#include <efi/protocol/device-path.h>
+#include <efi/protocol/graphics-output.h>
+#include <efi/protocol/simple-text-input.h>
+
 #include <cmdline.h>
 #include <magenta.h>
 #include <netboot.h>
 #include <utils.h>
 
-static EFI_GUID GraphicsOutputProtocol = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
-
 #define DEFAULT_TIMEOUT 3
 
 #define KBUFSIZE (32*1024*1024)
@@ -49,15 +51,15 @@
     BOOT_DEVICE_LOCAL,
 };
 
-int boot_prompt(EFI_SYSTEM_TABLE* sys, int timeout_s) {
-    EFI_BOOT_SERVICES* bs = sys->BootServices;
+int boot_prompt(efi_system_table* sys, int timeout_s) {
+    efi_boot_services* bs = sys->BootServices;
 
-    EFI_EVENT TimerEvent;
-    EFI_EVENT WaitList[2];
+    efi_event TimerEvent;
+    efi_event WaitList[2];
 
-    EFI_STATUS status;
-    UINTN Index;
-    EFI_INPUT_KEY key;
+    efi_status status;
+    size_t Index;
+    efi_input_key key;
     memset(&key, 0, sizeof(key));
 
     status = bs->CreateEvent(EVT_TIMER, 0, NULL, NULL, &TimerEvent);
@@ -117,7 +119,7 @@
     return BOOT_DEVICE_NETBOOT;
 }
 
-void set_graphics_mode(EFI_SYSTEM_TABLE* sys, EFI_GRAPHICS_OUTPUT_PROTOCOL* gop, char* cmdline) {
+void set_graphics_mode(efi_system_table* sys, efi_graphics_output_protocol* gop, char* cmdline) {
     if (!gop || !cmdline) return;
 
     char res[11];
@@ -134,12 +136,12 @@
     vres = atol(x);
     if (!hres || !vres) return;
 
-    UINT32 max_mode = gop->Mode->MaxMode;
+    uint32_t max_mode = gop->Mode->MaxMode;
 
     for (int i = 0; i < max_mode; i++) {
-        EFI_GRAPHICS_OUTPUT_MODE_INFORMATION* mode_info;
-        UINTN info_size = 0;
-        EFI_STATUS status = gop->QueryMode(gop, i, &info_size, &mode_info);
+        efi_graphics_output_mode_information* mode_info;
+        size_t info_size = 0;
+        efi_status status = gop->QueryMode(gop, i, &info_size, &mode_info);
         if (EFI_ERROR(status)) {
             printf("Could not retrieve mode %d: %s\n", i, efi_strerror(status));
             continue;
@@ -158,17 +160,17 @@
     sys->BootServices->Stall(5000000);
 }
 
-void draw_logo(EFI_GRAPHICS_OUTPUT_PROTOCOL* gop) {
+void draw_logo(efi_graphics_output_protocol* gop) {
     if (!gop) return;
 
     const uint32_t h_res = gop->Mode->Info->HorizontalResolution;
     const uint32_t v_res = gop->Mode->Info->VerticalResolution;
-    EFI_GRAPHICS_OUTPUT_BLT_PIXEL fuchsia = {
+    efi_graphics_output_blt_pixel fuchsia = {
         .Red = 0xFF,
         .Green = 0x0,
         .Blue = 0xFF,
     };
-    EFI_GRAPHICS_OUTPUT_BLT_PIXEL black = {
+    efi_graphics_output_blt_pixel black = {
         .Red = 0x0,
         .Green = 0x0,
         .Blue = 0x0
@@ -181,10 +183,10 @@
     gop->Blt(gop, &fuchsia, EfiBltVideoFill, 0, 0, 0, v_res - (v_res/100), h_res, v_res/100, 0);
 }
 
-void do_netboot(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys) {
-    EFI_BOOT_SERVICES* bs = sys->BootServices;
+void do_netboot(efi_handle img, efi_system_table* sys) {
+    efi_boot_services* bs = sys->BootServices;
 
-    EFI_PHYSICAL_ADDRESS mem = 0xFFFFFFFF;
+    efi_physical_addr mem = 0xFFFFFFFF;
     if (bs->AllocatePages(AllocateMaxAddress, EfiLoaderData, KBUFSIZE / 4096, &mem)) {
         printf("Failed to allocate network io buffer\n");
         return;
@@ -206,7 +208,7 @@
     cmdline[0] = 0;
 
     printf("\nNetBoot Server Started...\n\n");
-    EFI_TPL prev_tpl = bs->RaiseTPL(TPL_NOTIFY);
+    efi_tpl prev_tpl = bs->RaiseTPL(TPL_NOTIFY);
     for (;;) {
         int n = netboot_poll();
         if (n < 1) {
@@ -218,34 +220,34 @@
         }
         uint8_t* x = nbkernel.data;
         if ((x[0] == 'M') && (x[1] == 'Z') && (x[0x80] == 'P') && (x[0x81] == 'E')) {
-            UINTN exitdatasize;
-            EFI_STATUS r;
-            EFI_HANDLE h;
+            size_t exitdatasize;
+            efi_status r;
+            efi_handle h;
 
-            MEMMAP_DEVICE_PATH mempath[2] = {
+            efi_device_path_hw_memmap mempath[2] = {
                 {
                     .Header = {
-                        .Type = HARDWARE_DEVICE_PATH,
-                        .SubType = HW_MEMMAP_DP,
-                        .Length = { (UINT8)(sizeof(MEMMAP_DEVICE_PATH) & 0xff),
-                            (UINT8)((sizeof(MEMMAP_DEVICE_PATH) >> 8) & 0xff), },
+                        .Type = DEVICE_PATH_HARDWARE,
+                        .SubType = DEVICE_PATH_HW_MEMMAP,
+                        .Length = { (uint8_t)(sizeof(efi_device_path_hw_memmap) & 0xff),
+                            (uint8_t)((sizeof(efi_device_path_hw_memmap) >> 8) & 0xff), },
                     },
                     .MemoryType = EfiLoaderData,
-                    .StartingAddress = (EFI_PHYSICAL_ADDRESS)nbkernel.data,
-                    .EndingAddress = (EFI_PHYSICAL_ADDRESS)(nbkernel.data + nbkernel.offset),
+                    .StartAddress = (efi_physical_addr)nbkernel.data,
+                    .EndAddress = (efi_physical_addr)(nbkernel.data + nbkernel.offset),
                 },
                 {
                     .Header = {
-                        .Type = END_DEVICE_PATH_TYPE,
-                        .SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE,
-                        .Length = { (UINT8)(sizeof(EFI_DEVICE_PATH) & 0xff),
-                            (UINT8)((sizeof(EFI_DEVICE_PATH) >> 8) & 0xff), },
+                        .Type = DEVICE_PATH_END,
+                        .SubType = DEVICE_PATH_ENTIRE_END,
+                        .Length = { (uint8_t)(sizeof(efi_device_path_protocol) & 0xff),
+                            (uint8_t)((sizeof(efi_device_path_protocol) >> 8) & 0xff), },
                     },
                 },
             };
 
             printf("Attempting to run EFI binary...\n");
-            r = bs->LoadImage(FALSE, img, (EFI_DEVICE_PATH*)mempath, (void*)nbkernel.data, nbkernel.offset, &h);
+            r = bs->LoadImage(false, img, (efi_device_path_protocol*)mempath, (void*)nbkernel.data, nbkernel.offset, &h);
             if (EFI_ERROR(r)) {
                 printf("LoadImage Failed (%s)\n", efi_strerror(r));
                 continue;
@@ -269,7 +271,7 @@
         cmdline[nbcmdline.offset] = 0;
 
         // maybe it's a kernel image?
-        EFI_GRAPHICS_OUTPUT_PROTOCOL* gop;
+        efi_graphics_output_protocol* gop;
         bs->LocateProtocol(&GraphicsOutputProtocol, NULL, (void**)&gop);
         set_graphics_mode(sys, gop, cmdline);
 
@@ -280,10 +282,9 @@
     }
 }
 
-EFI_STATUS efi_main(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys) {
-    EFI_BOOT_SERVICES* bs = sys->BootServices;
+efi_status efi_main(efi_handle img, efi_system_table* sys) {
+    efi_boot_services* bs = sys->BootServices;
 
-    InitializeLib(img, sys);
     InitGoodies(img, sys);
 
     uint64_t mmio;
@@ -294,14 +295,14 @@
     }
 
     // Load the cmdline
-    UINTN csz = 0;
+    size_t csz = 0;
     char* cmdline = LoadFile(L"cmdline", &csz);
     if (cmdline) {
         cmdline[csz] = '\0';
         printf("cmdline: %s\n", cmdline);
     }
 
-    EFI_GRAPHICS_OUTPUT_PROTOCOL* gop;
+    efi_graphics_output_protocol* gop;
     bs->LocateProtocol(&GraphicsOutputProtocol, NULL, (void**)&gop);
     set_graphics_mode(sys, gop, cmdline);
     draw_logo(gop);
@@ -314,7 +315,7 @@
 
     // Look for a kernel image on disk
     // TODO: use the filesystem protocol
-    UINTN ksz = 0;
+    size_t ksz = 0;
     void* kernel = LoadFile(L"magenta.bin", &ksz);
 
     if (!have_network && kernel == NULL) {
@@ -339,7 +340,7 @@
             do_netboot(img, sys);
             break;
         case BOOT_DEVICE_LOCAL: {
-            UINTN rsz = 0;
+            size_t rsz = 0;
             void* ramdisk = LoadFile(L"ramdisk.bin", &rsz);
             boot_kernel(img, sys, kernel, ksz, ramdisk, rsz,
                         cmdline, csz, cmdextra, strlen(cmdextra));
diff --git a/src/pci.c b/src/pci.c
index 6bf0dfa..2aa0fd9 100644
--- a/src/pci.c
+++ b/src/pci.c
@@ -2,8 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <efi.h>
-#include <efilib.h>
+#include <efi/types.h>
 #include <efi/protocol/pci-root-bridge-io.h>
 
 #include <stdio.h>
@@ -54,10 +53,10 @@
 #define PCI_MAX_DEVICES 32
 #define PCI_MAX_FUNCS 8
 
-EFI_STATUS FindPCIMMIO(EFI_BOOT_SERVICES* bs, uint8_t cls, uint8_t sub, uint8_t ifc, uint64_t* mmio) {
-    UINTN num_handles;
-    EFI_HANDLE* handles;
-    EFI_STATUS status = bs->LocateHandleBuffer(ByProtocol, &PciRootBridgeIoProtocol,
+efi_status FindPCIMMIO(efi_boot_services* bs, uint8_t cls, uint8_t sub, uint8_t ifc, uint64_t* mmio) {
+    size_t num_handles;
+    efi_handle* handles;
+    efi_status status = bs->LocateHandleBuffer(ByProtocol, &PciRootBridgeIoProtocol,
             NULL, &num_handles, &handles);
     if (EFI_ERROR(status)) {
         printf("Could not find PCI root bridge IO protocol: %s\n", efi_strerror(status));
@@ -66,7 +65,7 @@
 
     for (int i = 0; i < num_handles; i++) {
         printf("handle %d\n", i);
-        EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL* iodev;
+        efi_pci_root_bridge_io_protocol* iodev;
         status = bs->HandleProtocol(handles[i], &PciRootBridgeIoProtocol, (void**)&iodev);
         if (EFI_ERROR(status)) {
             printf("Could not get protocol for handle %d: %s\n", i, efi_strerror(status));
@@ -79,10 +78,10 @@
             continue;
         }
 
-        UINT16 min_bus, max_bus;
+        uint16_t min_bus, max_bus;
         while (descriptors->descriptor != ACPI_END_TAG_DESCRIPTOR) {
-            min_bus = (UINT16)descriptors->addrrange_minimum;
-            max_bus = (UINT16)descriptors->addrrange_maximum;
+            min_bus = (uint16_t)descriptors->addrrange_minimum;
+            max_bus = (uint16_t)descriptors->addrrange_maximum;
 
             if (descriptors->res_type != ACPI_ADDRESS_SPACE_TYPE_BUS) {
                 descriptors++;
@@ -94,7 +93,7 @@
                     for (int func = 0; func < PCI_MAX_FUNCS; func++) {
                         pci_common_header_t pci_hdr;
                         bs->SetMem(&pci_hdr, sizeof(pci_hdr), 0);
-                        UINT64 address = (UINT64)((bus << 24) + (dev << 16) + (func << 8));
+                        uint64_t address = (uint64_t)((bus << 24) + (dev << 16) + (func << 8));
                         status = iodev->Pci.Read(iodev, EfiPciWidthUint16, address, sizeof(pci_hdr) / 2, &pci_hdr);
                         if (EFI_ERROR(status)) {
                             printf("could not read pci configuration for bus %d dev %d func %d: %s\n",
diff --git a/src/showmem.c b/src/showmem.c
index e8f7e16..d260ad8 100644
--- a/src/showmem.c
+++ b/src/showmem.c
@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <efi.h>
-#include <efilib.h>
+#include <efi/types.h>
+#include <efi/system-table.h>
 
 #include <printf.h>
 
-static const char* MemTypeName(UINT32 type, char* buf) {
+static const char* MemTypeName(uint32_t type, char* buf) {
     switch (type) {
     case EfiReservedMemoryType:
         return "Reserved";
@@ -45,16 +45,16 @@
 
 static unsigned char scratch[4096];
 
-static void dump_memmap(EFI_SYSTEM_TABLE* systab) {
-    EFI_STATUS r;
-    UINTN msize, off;
-    EFI_MEMORY_DESCRIPTOR* mmap;
-    UINTN mkey, dsize;
-    UINT32 dversion;
+static void dump_memmap(efi_system_table* systab) {
+    efi_status r;
+    size_t msize, off;
+    efi_memory_descriptor* mmap;
+    size_t mkey, dsize;
+    uint32_t dversion;
     char tmp[32];
 
     msize = sizeof(scratch);
-    mmap = (EFI_MEMORY_DESCRIPTOR*)scratch;
+    mmap = (efi_memory_descriptor*)scratch;
     mkey = dsize = dversion;
     r = systab->BootServices->GetMemoryMap(&msize, mmap, &mkey, &dsize, &dversion);
     printf("r=%lx msz=%lx key=%lx dsz=%lx dvn=%x\n",
@@ -63,7 +63,7 @@
         return;
     }
     for (off = 0; off < msize; off += dsize) {
-        mmap = (EFI_MEMORY_DESCRIPTOR*)(scratch + off);
+        mmap = (efi_memory_descriptor*)(scratch + off);
         printf("%016lx %016lx %08lx %c %04lx %s\n",
                mmap->PhysicalStart, mmap->VirtualStart,
                mmap->NumberOfPages,
@@ -75,8 +75,7 @@
 
 #include <utils.h>
 
-EFI_STATUS efi_main(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys) {
-    InitializeLib(img, sys);
+efi_status efi_main(efi_handle img, efi_system_table* sys) {
     InitGoodies(img, sys);
     dump_memmap(sys);
     WaitAnyKey();
diff --git a/src/usbtest.c b/src/usbtest.c
index cd6cff9..fddd734 100644
--- a/src/usbtest.c
+++ b/src/usbtest.c
@@ -2,23 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <efi.h>
-#include <efilib.h>
+#include <efi/types.h>
+#include <efi/protocol/device-path.h>
+#include <efi/protocol/driver-binding.h>
+#include <efi/protocol/usb-io.h>
 
 #include <utils.h>
 #include <stdio.h>
 
-#include <Protocol/UsbIo.h>
+EFIAPI efi_status MyDriverSupported(
+    efi_driver_binding_protocol* self, efi_handle ctlr,
+    efi_device_path_protocol* path) {
 
-EFI_GUID UsbIoProtocol = EFI_USB_IO_PROTOCOL_GUID;
-
-EFIAPI EFI_STATUS MyDriverSupported(
-    EFI_DRIVER_BINDING* self, EFI_HANDLE ctlr,
-    EFI_DEVICE_PATH* path) {
-
-    EFI_USB_DEVICE_DESCRIPTOR dev;
-    EFI_USB_IO_PROTOCOL* usbio;
-    EFI_STATUS r;
+    efi_usb_device_descriptor dev;
+    efi_usb_io_protocol* usbio;
+    efi_status r;
 
     r = gBS->OpenProtocol(ctlr, &UsbIoProtocol,
                           (void**)&usbio, self->DriverBindingHandle,
@@ -37,12 +35,12 @@
     return EFI_UNSUPPORTED;
 }
 
-EFIAPI EFI_STATUS MyDriverStart(
-    EFI_DRIVER_BINDING* self, EFI_HANDLE ctlr,
-    EFI_DEVICE_PATH* path) {
-    EFI_STATUS r;
+EFIAPI efi_status MyDriverStart(
+    efi_driver_binding_protocol* self, efi_handle ctlr,
+    efi_device_path_protocol* path) {
+    efi_status r;
 
-    EFI_USB_IO_PROTOCOL* usbio;
+    efi_usb_io_protocol* usbio;
 
     printf("Start! ctlr=%p\n", ctlr);
 
@@ -60,9 +58,9 @@
     return EFI_SUCCESS;
 }
 
-EFIAPI EFI_STATUS MyDriverStop(
-    EFI_DRIVER_BINDING* self, EFI_HANDLE ctlr,
-    UINTN count, EFI_HANDLE* children) {
+EFIAPI efi_status MyDriverStop(
+    efi_driver_binding_protocol* self, efi_handle ctlr,
+    size_t count, efi_handle* children) {
 
     printf("Stop! ctlr=%p\n", ctlr);
 
@@ -73,7 +71,7 @@
     return EFI_SUCCESS;
 }
 
-static EFI_DRIVER_BINDING MyDriver = {
+static efi_driver_binding_protocol MyDriver = {
     .Supported = MyDriverSupported,
     .Start = MyDriverStart,
     .Stop = MyDriverStop,
@@ -82,18 +80,18 @@
     .DriverBindingHandle = NULL,
 };
 
-void InstallMyDriver(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys) {
-    EFI_BOOT_SERVICES* bs = sys->BootServices;
-    EFI_HANDLE* list;
-    UINTN count, i;
-    EFI_STATUS r;
+void InstallMyDriver(efi_handle img, efi_system_table* sys) {
+    efi_boot_services* bs = sys->BootServices;
+    efi_handle* list;
+    size_t count, i;
+    efi_status r;
 
     MyDriver.ImageHandle = img;
     MyDriver.DriverBindingHandle = img;
     r = bs->InstallProtocolInterface(&img, &DriverBindingProtocol,
                                      EFI_NATIVE_INTERFACE, &MyDriver);
     if (r) {
-        Print(L"DriverBinding failed %lx\n", r);
+        printf("DriverBinding failed %lx\n", r);
         return;
     }
 
@@ -101,17 +99,17 @@
     r = bs->LocateHandleBuffer(ByProtocol, &UsbIoProtocol, NULL, &count, &list);
     if (r == 0) {
         for (i = 0; i < count; i++) {
-            r = bs->ConnectController(list[i], NULL, NULL, FALSE);
+            r = bs->ConnectController(list[i], NULL, NULL, false);
         }
         bs->FreePool(list);
     }
 }
 
-void RemoveMyDriver(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys) {
-    EFI_BOOT_SERVICES* bs = sys->BootServices;
-    EFI_HANDLE* list;
-    UINTN count, i;
-    EFI_STATUS r;
+void RemoveMyDriver(efi_handle img, efi_system_table* sys) {
+    efi_boot_services* bs = sys->BootServices;
+    efi_handle* list;
+    size_t count, i;
+    efi_status r;
 
     // Disconnect the driver
     r = bs->LocateHandleBuffer(ByProtocol, &UsbIoProtocol, NULL, &count, &list);
@@ -128,11 +126,10 @@
         printf("UninstallProtocol failed %lx\n", r);
 }
 
-EFI_STATUS efi_main(EFI_HANDLE img, EFI_SYSTEM_TABLE* sys) {
-    InitializeLib(img, sys);
+efi_status efi_main(efi_handle img, efi_system_table* sys) {
     InitGoodies(img, sys);
 
-    Print(L"Hello, EFI World\n");
+    printf("Hello, EFI World\n");
 
     InstallMyDriver(img, sys);
 
diff --git a/third_party/gnu-efi/Makefile b/third_party/gnu-efi/Makefile
index 3d4275c..0f754bc 100644
--- a/third_party/gnu-efi/Makefile
+++ b/third_party/gnu-efi/Makefile
@@ -42,8 +42,7 @@
 
 include $(SRCDIR)/Make.defaults
 
-SUBDIRS = lib gnuefi inc apps
-gnuefi: lib
+SUBDIRS = gnuefi
 
 all:	check_gcc $(SUBDIRS)