diff --git a/src/api/event.c b/src/api/event.c
index 834a6c42..722eaac2 100644
--- a/src/api/event.c
+++ b/src/api/event.c
@@ -33,39 +33,28 @@ static int nextEvent(lua_State* L) {
       return 2;
 
     case EVENT_FOCUS:
-      lua_pushboolean(L, event.data.focus.focused);
-      return 2;
-
     case EVENT_MOUNT:
-      lua_pushboolean(L, event.data.mount.mounted);
+      lua_pushboolean(L, event.data.boolean.value);
       return 2;
 
 #ifndef EMSCRIPTEN
     case EVENT_THREAD_ERROR:
-      luax_pushobject(L, event.data.threaderror.thread);
-      lua_pushstring(L, event.data.threaderror.error);
-      free((void*) event.data.threaderror.error);
+      luax_pushobject(L, event.data.thread.thread);
+      lua_pushstring(L, event.data.thread.error);
+      free((void*) event.data.thread.error);
       return 3;
 #endif
 
     case EVENT_CONTROLLER_ADDED:
-      luax_pushobject(L, event.data.controlleradded.controller);
-      lovrRelease(event.data.controlleradded.controller);
-      return 2;
-
     case EVENT_CONTROLLER_REMOVED:
-      luax_pushobject(L, event.data.controllerremoved.controller);
-      lovrRelease(event.data.controlleradded.controller);
+      luax_pushobject(L, event.data.controller.controller);
+      lovrRelease(event.data.controller.controller);
       return 2;
 
     case EVENT_CONTROLLER_PRESSED:
-      luax_pushobject(L, event.data.controllerpressed.controller);
-      lua_pushstring(L, ControllerButtons[event.data.controllerpressed.button]);
-      return 3;
-
     case EVENT_CONTROLLER_RELEASED:
-      luax_pushobject(L, event.data.controllerreleased.controller);
-      lua_pushstring(L, ControllerButtons[event.data.controllerpressed.button]);
+      luax_pushobject(L, event.data.controller.controller);
+      lua_pushstring(L, ControllerButtons[event.data.controller.button]);
       return 3;
 
     default:
@@ -114,11 +103,8 @@ int l_lovrEventPush(lua_State* L) {
       break;
 
     case EVENT_FOCUS:
-      data.focus.focused = lua_toboolean(L, 2);
-      break;
-
     case EVENT_MOUNT:
-      data.mount.mounted = lua_toboolean(L, 2);
+      data.boolean.value = lua_toboolean(L, 2);
       break;
 
 #ifdef EMSCRIPTEN
@@ -126,27 +112,20 @@ int l_lovrEventPush(lua_State* L) {
       break;
 #else
     case EVENT_THREAD_ERROR:
-      data.threaderror.thread = luax_checktype(L, 2, Thread);
-      data.threaderror.error = luaL_checkstring(L, 3);
+      data.thread.thread = luax_checktype(L, 2, Thread);
+      data.thread.error = luaL_checkstring(L, 3);
       break;
 #endif
 
     case EVENT_CONTROLLER_ADDED:
-      data.controlleradded.controller = luax_checktype(L, 2, Controller);
-      break;
-
     case EVENT_CONTROLLER_REMOVED:
-      data.controllerremoved.controller = luax_checktype(L, 2, Controller);
+      data.controller.controller = luax_checktype(L, 2, Controller);
       break;
 
     case EVENT_CONTROLLER_PRESSED:
-      data.controllerpressed.controller = luax_checktype(L, 2, Controller);
-      data.controllerpressed.button = luaL_checkoption(L, 3, NULL, ControllerButtons);
-      break;
-
     case EVENT_CONTROLLER_RELEASED:
-      data.controllerreleased.controller = luax_checktype(L, 2, Controller);
-      data.controllerreleased.button = luaL_checkoption(L, 3, NULL, ControllerButtons);
+      data.controller.controller = luax_checktype(L, 2, Controller);
+      data.controller.button = luaL_checkoption(L, 3, NULL, ControllerButtons);
       break;
   }
 
diff --git a/src/api/thread.c b/src/api/thread.c
index 70124ed1..d4a994d4 100644
--- a/src/api/thread.c
+++ b/src/api/thread.c
@@ -27,11 +27,10 @@ static int threadRunner(void* data) {
   lovrRelease(thread);
 
   if (thread->error) {
-    Event event;
-    event.type = EVENT_THREAD_ERROR;
-    event.data.threaderror.thread = thread;
-    event.data.threaderror.error = strdup(thread->error);
-    lovrEventPush(event);
+    lovrEventPush((Event) {
+      .type = EVENT_THREAD_ERROR,
+      .data.thread = { thread, strdup(thread->error) }
+    });
     lua_close(L);
     return 1;
   }
diff --git a/src/event/event.h b/src/event/event.h
index 9f41f0c3..6ac506b5 100644
--- a/src/event/event.h
+++ b/src/event/event.h
@@ -24,49 +24,28 @@ typedef struct {
 } QuitEvent;
 
 typedef struct {
-  bool focused;
-} FocusEvent;
-
-typedef struct {
-  bool mounted;
-} MountEvent;
+  bool value;
+} BoolEvent;
 
 #ifndef EMSCRIPTEN
 typedef struct {
   Thread* thread;
   const char* error;
-} ThreadErrorEvent;
+} ThreadEvent;
 #endif
 
-typedef struct {
-  Controller* controller;
-} ControllerAddedEvent;
-
-typedef struct {
-  Controller* controller;
-} ControllerRemovedEvent;
-
 typedef struct {
   Controller* controller;
   ControllerButton button;
-} ControllerPressedEvent;
-
-typedef struct {
-  Controller* controller;
-  ControllerButton button;
-} ControllerReleasedEvent;
+} ControllerEvent;
 
 typedef union {
   QuitEvent quit;
-  FocusEvent focus;
-  MountEvent mount;
+  BoolEvent boolean;
 #ifndef EMSCRIPTEN
-  ThreadErrorEvent threaderror;
+  ThreadEvent thread;
 #endif
-  ControllerAddedEvent controlleradded;
-  ControllerRemovedEvent controllerremoved;
-  ControllerPressedEvent controllerpressed;
-  ControllerReleasedEvent controllerreleased;
+  ControllerEvent controller;
 } EventData;
 
 typedef struct {
diff --git a/src/graphics/graphics.c b/src/graphics/graphics.c
index 1d7843ce..561af2c2 100644
--- a/src/graphics/graphics.c
+++ b/src/graphics/graphics.c
@@ -15,7 +15,7 @@ static GraphicsState state;
 
 static void onCloseWindow(GLFWwindow* window) {
   if (window == state.window) {
-    lovrEventPush((Event) { .type = EVENT_QUIT, .data = { .quit = { false, 0 } } });
+    lovrEventPush((Event) { .type = EVENT_QUIT, .data.quit = { false, 0 } });
   }
 }
 
diff --git a/src/headset/fake.c b/src/headset/fake.c
index 788c3750..1a5c36d9 100644
--- a/src/headset/fake.c
+++ b/src/headset/fake.c
@@ -92,21 +92,14 @@ static void onMouseButton(GLFWwindow* window, int button, int action, int mods)
     return;
   }
 
-  Event event;
   Controller* controller;
   int i;
   vec_foreach(&state.controllers, controller, i) {
     if (button == GLFW_MOUSE_BUTTON_RIGHT) {
-      if (action == GLFW_PRESS) {
-        event.type = EVENT_CONTROLLER_PRESSED;
-        event.data.controllerpressed.controller = controller;
-        event.data.controllerpressed.button = CONTROLLER_BUTTON_TRIGGER;
-      } else {
-        event.type = EVENT_CONTROLLER_RELEASED;
-        event.data.controllerreleased.controller = controller;
-        event.data.controllerreleased.button = CONTROLLER_BUTTON_TRIGGER;
-      }
-      lovrEventPush(event);
+      lovrEventPush((Event) {
+        .type = action == GLFW_PRESS ? EVENT_CONTROLLER_PRESSED : EVENT_CONTROLLER_RELEASED,
+        .data.controller = { controller, CONTROLLER_BUTTON_TRIGGER }
+      });
     }
   }
 }
diff --git a/src/headset/openvr.c b/src/headset/openvr.c
index 00d5d01d..78cdcfe5 100644
--- a/src/headset/openvr.c
+++ b/src/headset/openvr.c
@@ -86,11 +86,11 @@ static void openvrRefreshControllers() {
   Controller* controller; int i;
   vec_foreach_rev(&state.controllers, controller, i) {
     if (controller->id != controllerIds[0] && controller->id != controllerIds[1]) {
-      EventType type = EVENT_CONTROLLER_REMOVED;
-      EventData data = { .controllerremoved = { controller } };
-      Event event = { .type = type, .data = data };
       lovrRetain(controller);
-      lovrEventPush(event);
+      lovrEventPush((Event) {
+        .type = EVENT_CONTROLLER_REMOVED,
+        .data.controller = { controller, 0 }
+      });
       vec_splice(&state.controllers, i, 1);
       lovrRelease(controller);
     }
@@ -101,11 +101,11 @@ static void openvrRefreshControllers() {
     if ((int) controllerIds[i] != -1) {
       controller = openvrAddController(controllerIds[i]);
       if (!controller) continue;
-      EventType type = EVENT_CONTROLLER_ADDED;
-      EventData data = { .controlleradded = { controller } };
-      Event event = { .type = type, .data = data };
       lovrRetain(controller);
-      lovrEventPush(event);
+      lovrEventPush((Event) {
+        .type = EVENT_CONTROLLER_ADDED,
+        .data.controller = { controller, 0 }
+      });
     }
   }
 }
@@ -188,8 +188,7 @@ static void openvrPoll() {
         bool isPress = vrEvent.eventType == EVREventType_VREvent_ButtonPress;
 
         if (vrEvent.trackedDeviceIndex == state.headsetIndex && vrEvent.data.controller.button == EVRButtonId_k_EButton_ProximitySensor) {
-          Event event = { .type = EVENT_MOUNT, .data = { .mount = { isPress } } };
-          lovrEventPush(event);
+          lovrEventPush((Event) { .type = EVENT_MOUNT, .data.boolean = { isPress } });
           break;
         }
 
@@ -197,15 +196,10 @@ static void openvrPoll() {
           Controller* controller = state.controllers.data[i];
           if (controller->id == vrEvent.trackedDeviceIndex) {
             ControllerButton button = getButton(vrEvent.data.controller.button, openvrControllerGetHand(controller));
-            if (isPress) {
-              EventData data = { .controllerpressed = { controller, button } };
-              Event event = { .type = EVENT_CONTROLLER_PRESSED, .data = data };
-              lovrEventPush(event);
-            } else {
-              EventData data = { .controllerreleased = { controller, button } };
-              Event event = { .type = EVENT_CONTROLLER_RELEASED, .data = data };
-              lovrEventPush(event);
-            }
+            lovrEventPush((Event) {
+              .type = isPress ? EVENT_CONTROLLER_PRESSED : EVENT_CONTROLLER_RELEASED,
+              .data.controller = { controller, button }
+            });
             break;
           }
         }
@@ -215,9 +209,7 @@ static void openvrPoll() {
       case EVREventType_VREvent_InputFocusCaptured:
       case EVREventType_VREvent_InputFocusReleased: {
         bool isFocused = vrEvent.eventType == EVREventType_VREvent_InputFocusReleased;
-        EventData data = { .focus = { isFocused } };
-        Event event = { .type = EVENT_FOCUS, .data = data };
-        lovrEventPush(event);
+        lovrEventPush((Event) { .type = EVENT_FOCUS, .data.boolean = { isFocused } });
         break;
       }
 
diff --git a/src/headset/webvr.c b/src/headset/webvr.c
index 5f45af63..7914169f 100644
--- a/src/headset/webvr.c
+++ b/src/headset/webvr.c
@@ -45,7 +45,7 @@ static void onControllerAdded(uint32_t id) {
   lovrRetain(controller);
   lovrEventPush((Event) {
     .type = EVENT_CONTROLLER_ADDED,
-    .data = { .controlleradded = { controller } }
+    .data.controller = { controller, 0 }
   });
 }
 
@@ -56,7 +56,7 @@ static void onControllerRemoved(uint32_t id) {
       lovrRetain(controller);
       lovrEventPush((Event) {
         .type = EVENT_CONTROLLER_REMOVED,
-        .data = { .controllerremoved = { controller } }
+        .data.controller = { controller, 0 }
       });
       vec_splice(&state.controllers, i, 1);
       lovrRelease(controller);
@@ -68,21 +68,21 @@ static void onControllerRemoved(uint32_t id) {
 static void onControllerPressed(uint32_t id, ControllerButton button) {
   lovrEventPush((Event) {
     .type = EVENT_CONTROLLER_PRESSED,
-    .data = { .controllerpressed = { state.controllers.data[id], button } }
+    .data.controller = { state.controllers.data[id], button }
   });
 }
 
 static void onControllerReleased(uint32_t id, ControllerButton button) {
   lovrEventPush((Event) {
     .type = EVENT_CONTROLLER_RELEASED,
-    .data = { .controllerreleased = { state.controllers.data[id], button } }
+    .data.controller = { state.controllers.data[id], button }
   });
 }
 
 static void onMountChanged(bool mounted) {
   lovrEventPush((Event) {
     .type = EVENT_MOUNT,
-    .data = { .mount = { mounted } }
+    .data.boolean = { mounted }
   });
 }
 
diff --git a/src/lovr.c b/src/lovr.c
index 5b64c309..b5213936 100644
--- a/src/lovr.c
+++ b/src/lovr.c
@@ -131,10 +131,7 @@ bool lovrRun(int argc, char** argv, int* status) {
 }
 
 void lovrQuit(int status) {
-  EventType type = EVENT_QUIT;
-  EventData data = { .quit = { false, status } };
-  Event event = { .type = type, .data = data };
-  lovrEventPush(event);
+  lovrEventPush((Event) { .type = EVENT_QUIT, .data.quit = { false, status } });
 }
 
 const char* lovrGetOS() {