diff --git a/Android.mk b/Android.mk
index 0b9a9d6..8234410 100644
--- a/Android.mk
+++ b/Android.mk
@@ -105,27 +105,4 @@
 
 include $(BUILD_SHARED_LIBRARY)
 
-#########################################################################
-# Build stand-alone quake executable on device
-#########################################################################
-
-ifneq ($(BUILD_TINY_ANDROID),true)
-ifeq ($(TARGET_ARCH),arm)
-
-LOCAL_PATH:= $(TOP_LOCAL_PATH)/standalone
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= main.cpp
-
-LOCAL_SHARED_LIBRARIES := libc libm libutils libui libquake libEGL libGLESv1_CM
-
-LOCAL_MODULE:= quake
-
-LOCAL_MODULE_TAGS := optional
-
-include $(BUILD_EXECUTABLE)
-
-endif
-endif
-
 endif # TARGET_SIMULATOR
diff --git a/standalone/main.cpp b/standalone/main.cpp
deleted file mode 100644
index 7a5b6ee..0000000
--- a/standalone/main.cpp
+++ /dev/null
@@ -1,362 +0,0 @@
-#include <stdio.h>
-#include <unistd.h>
-#include <EGL/egl.h>
-#include <GLES/gl.h>
-#include <pthread.h>
-#include <ui/EventHub.h>
-#include <ui/FramebufferNativeWindow.h>
-#include <ui/EGLUtils.h>
-
-extern void AndroidInitArgs(int argc, char** argv);
-extern int AndroidInit();
-extern int AndroidMotionEvent(unsigned long long eventTime, int action,
-        float x, float y, float pressure, float size, int deviceId);
-extern int AndroidEvent(int type, int value);
-extern int AndroidStep(int width, int height);
-
-static int gDisplayWidth;
-static int gDisplayHeight;
-static EGLDisplay gDisplay;
-static EGLSurface gSurface;
-static EGLContext gContext;
-
-void checkEGLError(const char* msg) {
-    unsigned int error = eglGetError();
-    if (error != EGL_SUCCESS) {
-        fprintf(stderr, "%s: error %u\n", msg, error);
-    }
-}
-
-void checkGLError(const char* msg) {
-    unsigned int error = glGetError();
-    if (error != GL_NO_ERROR) {
-        fprintf(stderr, "%s: error 0x%04X\n", msg, error);
-    }
-}
-
-static android::sp<android::EventHub> gHub;
-
-class EventQueue {
-private:
-    class Lock {
-    public:
-        Lock(pthread_mutex_t& mutex) {
-            m_pMutex = &mutex;
-            pthread_mutex_lock(m_pMutex);
-        }
-        ~Lock() {
-            pthread_mutex_unlock(m_pMutex);
-        }
-        void wait(pthread_cond_t& cond) {
-            pthread_cond_wait(&cond, m_pMutex);
-        }
-        void signal(pthread_cond_t& cond) {
-            pthread_cond_signal(&cond);
-        }
-    private:
-        pthread_mutex_t* m_pMutex;
-    };
-    
-public:
-    
-    static const int MOTION_ACTION_DOWN = 0;
-    static const int MOTION_ACTION_UP = 1;
-    static const int MOTION_ACTION_MOVE = 2;
-
-// Platform-specific event types.
-
-    static const int EV_DEVICE_ADDED = android::EventHub::DEVICE_ADDED;
-    static const int EV_DEVICE_REMOVED = android::EventHub::DEVICE_REMOVED;
-    
-    struct Event {
-        int32_t deviceId;
-        int32_t type;
-        int32_t scancode;
-        int32_t keycode;
-        uint32_t flags;
-        int32_t value;
-        nsecs_t when;
-    };
-    
-    EventQueue() {
-        m_Head = 0;
-        m_Count = 0;
-        pthread_mutex_init(&m_mutex, NULL);
-        pthread_cond_init(&m_space_available, NULL);
-        startEventThread();
-    }
-    
-    // Returns NULL if no event available.
-    // Call recycleEvent when you're done with the event
-    Event* getEvent() {
-        Event* result = NULL;
-        Lock lock(m_mutex);
-        if (m_Count > 0) {
-            result = m_Events + m_Head;
-        }
-        return result;
-    }
-    
-    void recycleEvent(Event* pEvent) {
-        Lock lock(m_mutex);
-        if (pEvent == m_Events + m_Head && m_Count > 0) {
-            m_Head = incQueue(m_Head);
-            m_Count--;
-            lock.signal(m_space_available);
-        }
-    }
-    
-private:
-    inline size_t incQueue(size_t index) {
-        return modQueue(index + 1);
-    }
-    
-    inline size_t modQueue(size_t index) {
-        return index & EVENT_SIZE_MASK;
-    }
-    
-    void startEventThread() {
-        pthread_create( &m_eventThread, NULL, &staticEventThreadMain, this);
-    }
-    
-    static void* staticEventThreadMain(void* arg) {
-        return ((EventQueue*) arg)->eventThreadMain();
-    }
-    
-    void* eventThreadMain() {
-        gHub = new android::EventHub();
-        while(true) {
-            android::RawEvent rawEvent;
-            bool result = gHub->getEvent(& rawEvent);
-            if (result) {
-                Event event;
-                event.deviceId = rawEvent.deviceId;
-                event.when = rawEvent.when;
-                event.type = rawEvent.type;
-                event.value = rawEvent.value;
-                event.keycode = rawEvent.keyCode;
-                event.scancode = rawEvent.scanCode;
-                event.flags = rawEvent.flags;
-
-                Lock lock(m_mutex);
-                while( m_Count == MAX_EVENTS) {
-                    lock.wait(m_space_available);
-                }
-                m_Events[modQueue(m_Head + m_Count)] = event;
-                m_Count = incQueue(m_Count);
-            }
-        }
-        return NULL;
-    }
-
-    static const size_t MAX_EVENTS = 16;
-    static const size_t EVENT_SIZE_MASK = 0xf;
-    
-    pthread_t m_eventThread;
-    pthread_mutex_t m_mutex;
-    pthread_cond_t  m_space_available;
-    unsigned int m_Head;
-    unsigned int m_Count;
-    Event m_Events[MAX_EVENTS];
-};
-
-bool gNoEvents;
-EventQueue* gpEventQueue;
-
-int init(int argc, char** argv) {
-    
-    for(int i = 0; i < argc; i++) {
-        char* p = argv[i];
-        if (strcmp(p, "-noevents") == 0) {
-            printf("-noevents: will not look for events.\n");
-            gNoEvents = true;
-        }
-    }
-    
-    if (! gNoEvents) {
-        gpEventQueue = new EventQueue();
-    }
-
-    EGLNativeWindowType window = android_createDisplaySurface();
-
-    gDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-    
-    EGLint majorVersion;
-    EGLint minorVersion;
-    
-    eglInitialize(gDisplay, &majorVersion, &minorVersion);
-    checkEGLError("eglInitialize");
-        
-    EGLint configRequest[] = {
-            EGL_SURFACE_TYPE, EGL_PBUFFER_BIT|EGL_WINDOW_BIT,
-            EGL_DEPTH_SIZE, 16,
-            EGL_NONE
-    };
- 
-    EGLConfig config;
-    android::EGLUtils::selectConfigForNativeWindow(gDisplay, configRequest, window, &config);
-    gSurface = eglCreateWindowSurface(gDisplay, config, window, NULL);
-
-    eglQuerySurface(gDisplay, gSurface, EGL_WIDTH, &gDisplayWidth);
-    eglQuerySurface(gDisplay, gSurface, EGL_HEIGHT, &gDisplayHeight);
-    fprintf(stderr, "display width = %d, height = %d\n", gDisplayWidth,
-            gDisplayHeight);
-
-    gContext = eglCreateContext(gDisplay, config, NULL, NULL);
-    checkEGLError("eglCreateContext");
-    eglMakeCurrent(gDisplay, gSurface, gSurface, gContext);
-    checkEGLError("eglMakeCurrent");
-    
-    printf("vendor    : %s\n", glGetString(GL_VENDOR));
-    printf("renderer  : %s\n", glGetString(GL_RENDERER));
-    printf("version   : %s\n", glGetString(GL_VERSION));
-    printf("extensions: %s\n", glGetString(GL_EXTENSIONS));
-        
-    return 0;
-}
-
-// Quick and dirty implementation of absolute pointer events...
-
-bool lastAbsDown = false;
-bool absDown = false;
-bool absChanged = false;
-unsigned long long absDownTime = 0;
-int absX = 0;
-int absY = 0;
-int absPressure = 0;
-int absSize = 0;
-int lastAbsX = 0;
-int lastAbsY = 0;
-int lastAbsPressure = 0;
-int lastAbsSize = 0;
-
-
-void checkEvents() {
-    
-    if (gpEventQueue == NULL) {
-        return;
-    }
-    while(true) {
-        EventQueue::Event* pEvent = gpEventQueue->getEvent();
-        if (pEvent == NULL) {
-            return;
-        }
-#if 1
-        printf("Event deviceId: %d, type: %d, scancode: %d,  keyCode: %d, flags: %d, value: %d, when: %llu\n",
-                pEvent->deviceId, pEvent->type, pEvent->scancode,
-                pEvent->keycode, pEvent->flags, pEvent->value, pEvent->when);
-#endif
-        switch (pEvent->type) {
-        case EV_KEY: // Keyboard input
-            if (pEvent->scancode == BTN_TOUCH) {
-                absDown = pEvent->value != 0;
-                absChanged = true;
-            }
-            else {
-                AndroidEvent(pEvent->value, pEvent->keycode);
-            }
-            break;
-            
-        case EV_ABS:
-            if (pEvent->scancode == ABS_X) {
-                absX = pEvent->value;
-                absChanged = true;
-            } else if (pEvent->scancode == ABS_Y) {
-                absY = pEvent->value;
-                absChanged = true;
-            } else if (pEvent->scancode == ABS_PRESSURE) {
-                absPressure = pEvent->value;
-                absChanged = true;
-            } else if (pEvent->scancode == ABS_TOOL_WIDTH) {
-                absSize = pEvent->value;
-                absChanged = true;
-            }
-
-        case EV_SYN:
-        {
-            if (absChanged) {
-                 absChanged = false;
-                 int action;
-                 if (absDown != lastAbsDown) {
-                     lastAbsDown = absDown;
-                     if (absDown) {
-                         action = EventQueue::MOTION_ACTION_DOWN;
-                         absDownTime = pEvent->when;
-                     } else {
-                         action = EventQueue::MOTION_ACTION_UP;
-                         absX = lastAbsX;
-                         absY = lastAbsY;
-                         absPressure = lastAbsPressure;
-                         absSize = lastAbsSize;
-                     }
-                 } else {
-                     action = EventQueue::MOTION_ACTION_MOVE;
-                 }
-                 float scaledX = absX;
-                 float scaledY = absY;
-                 float scaledPressure = 1.0f;
-                 float scaledSize = 0;
-#if 0
-                 if (di != null) {
-                     if (di.absX != null) {
-                         scaledX = ((scaledX-di.absX.minValue)
-                                     / di.absX.range)
-                                 * (mDisplay.getWidth()-1);
-                     }
-                     if (di.absY != null) {
-                         scaledY = ((scaledY-di.absY.minValue)
-                                     / di.absY.range)
-                                 * (mDisplay.getHeight()-1);
-                     }
-                     if (di.absPressure != null) {
-                         scaledPressure = 
-                             ((absPressure-di.absPressure.minValue)
-                                     / (float)di.absPressure.range);
-                     }
-                     if (di.absSize != null) {
-                         scaledSize = 
-                             ((absSize-di.absSize.minValue)
-                                     / (float)di.absSize.range);
-                     }
-                 }
-#endif
-
-                 unsigned long long whenMS = pEvent->when / 1000000;
-                 AndroidMotionEvent(whenMS, action,
-                         scaledX, scaledY, scaledPressure, scaledSize,
-                         pEvent->deviceId);
-                 lastAbsX = absX;
-                 lastAbsY = absY;
-            }
-        }
-        break;
-        
-        default:
-            break;
-        }
-        gpEventQueue->recycleEvent(pEvent);
-    }
-}
-
-int main(int argc, char** argv) {
-    fprintf(stderr, "Welcome to stand-alone Android quake.\n");
-    AndroidInitArgs(argc, argv);
-    
-    int result = init(argc, argv);
-    if (result) {
-        return result;
-    }
-    
-    if (!AndroidInit()) {
-        return 1;
-    }
-
-    while(true) {
-        AndroidStep(gDisplayWidth, gDisplayHeight);
-        checkGLError("AndroidStep");
-        eglSwapBuffers(gDisplay, gSurface);
-        checkEGLError("eglSwapBuffers");
-        checkEvents();
-    }
-    return 0;
-}