find_library(GHOSTTY_LIB ghostty)
target_link_libraries(your_app ${GHOSTTY_LIB})
target_include_directories(your_app PRIVATE /path/to/ghostty/include)

<!-- Link against libghostty.a or libghostty.dylib -->
<!-- Add include/ghostty.h to Header Search Paths -->

const exe = b.addExecutable(.{
    .name = "your_app",
    .target = target,
    .optimize = optimize,
});
exe.linkLibrary(ghostty_lib);
exe.addIncludePath(.{ .path = "path/to/include" });

#include <ghostty.h>

int main(int argc, char** argv) {
    // Initialize ghostty
    if (ghostty_init(argc, (char**)argv) != GHOSTTY_SUCCESS) {
        fprintf(stderr, "Failed to initialize ghostty\n");
        return 1;
    }
    
    // Rest of your application...
}

// Create new config
ghostty_config_t config = ghostty_config_new();

// Load configuration from default files
// This looks for ~/.config/ghostty/config
ghostty_config_load_default_files(config);

// Or load from a specific file
ghostty_config_load_file(config, "/path/to/config");

// Finalize configuration (required)
ghostty_config_finalize(config);

// Check for configuration errors
uint32_t diag_count = ghostty_config_diagnostics_count(config);
for (uint32_t i = 0; i < diag_count; i++) {
    ghostty_diagnostic_s diag = ghostty_config_get_diagnostic(config, i);
    fprintf(stderr, "Config error: %s\n", diag.message);
}

// Called when libghostty needs the event loop to wake up
void my_wakeup_cb(void* userdata) {
    MyApp* app = (MyApp*)userdata;
    // Signal your event loop to wake up
    dispatch_async(app->main_queue, ^{
        // Process pending events
    });
}

// Called when terminal requests an action
bool my_action_cb(ghostty_app_t app, 
                  ghostty_target_s target,
                  ghostty_action_s action) {
    switch (action.tag) {
        case GHOSTTY_ACTION_RING_BELL:
            // Ring the terminal bell
            NSBeep();
            return true;
            
        case GHOSTTY_ACTION_SET_TITLE:
            // Update window title
            update_window_title(action.action.set_title.title);
            return true;
            
        case GHOSTTY_ACTION_DESKTOP_NOTIFICATION:
            // Show a notification
            show_notification(
                action.action.desktop_notification.title,
                action.action.desktop_notification.body
            );
            return true;
            
        default:
            // Unhandled action
            return false;
    }
}

// Called when terminal needs clipboard access
void my_read_clipboard_cb(void* userdata,
                          ghostty_clipboard_e clipboard,
                          void* request_userdata) {
    const char* text = get_clipboard_text(clipboard);
    // Complete the clipboard request
    ghostty_surface_complete_clipboard_request(
        (ghostty_surface_t)request_userdata,
        text,
        request_userdata,
        true
    );
}

void my_write_clipboard_cb(void* userdata,
                           ghostty_clipboard_e clipboard,
                           const ghostty_clipboard_content_s* content,
                           size_t content_count,
                           bool confirm) {
    // Write to clipboard
    for (size_t i = 0; i < content_count; i++) {
        if (strcmp(content[i].mime, "text/plain") == 0) {
            set_clipboard_text(clipboard, content[i].data);
            break;
        }
    }
}

void my_close_surface_cb(void* userdata, bool confirmed) {
    MyApp* app = (MyApp*)userdata;
    // Close the terminal surface/window
    close_terminal_window(app);
}

// Set up runtime configuration
ghostty_runtime_config_s runtime = {
    .userdata = my_app_instance,
    .supports_selection_clipboard = true,  // X11 selection support
    .wakeup_cb = my_wakeup_cb,
    .action_cb = my_action_cb,
    .read_clipboard_cb = my_read_clipboard_cb,
    .write_clipboard_cb = my_write_clipboard_cb,
    .close_surface_cb = my_close_surface_cb,
};

// Create app
ghostty_app_t app = ghostty_app_new(&runtime, config);
if (!app) {
    fprintf(stderr, "Failed to create app\n");
    return 1;
}

// Keyboard input
void on_key_event(NSEvent* event) {
    ghostty_input_key_s key = {
        .action = event.isARepeat ? GHOSTTY_ACTION_REPEAT : GHOSTTY_ACTION_PRESS,
        .mods = convert_modifiers(event.modifierFlags),
        .consumed_mods = GHOSTTY_MODS_NONE,
        .keycode = event.keyCode,
        .text = [event.characters UTF8String],
        .unshifted_codepoint = 0,
        .composing = false,
    };
    
    ghostty_surface_key(surface, key);
}

// Mouse input
void on_mouse_button(NSEvent* event) {
    ghostty_input_mouse_button_e button = GHOSTTY_MOUSE_LEFT;
    ghostty_input_mouse_state_e state = 
        (event.type == NSEventTypeLeftMouseDown) ?
        GHOSTTY_MOUSE_PRESS : GHOSTTY_MOUSE_RELEASE;
    ghostty_input_mods_e mods = convert_modifiers(event.modifierFlags);
    
    ghostty_surface_mouse_button(surface, state, button, mods);
}

void on_mouse_move(NSEvent* event) {
    NSPoint point = [myView convertPoint:event.locationInWindow fromView:nil];
    ghostty_surface_mouse_pos(
        surface,
        point.x,
        point.y,
        convert_modifiers(event.modifierFlags)
    );
}

void on_scroll(NSEvent* event) {
    ghostty_surface_mouse_scroll(
        surface,
        event.scrollingDeltaX,
        event.scrollingDeltaY,
        convert_modifiers(event.modifierFlags)
    );
}

void render_frame() {
    // Tick the app (process IO, timers, etc.)
    ghostty_app_tick(app);
    
    // Draw the surface
    ghostty_surface_draw(surface);
    
    // Platform-specific presentation
    // (handled by libghostty internally for Metal/OpenGL)
}

// Handle resize
void on_resize(uint32_t width, uint32_t height) {
    ghostty_surface_set_size(surface, width, height);
}

// Handle scale factor changes (e.g., moving between displays)
void on_scale_change(double scale_x, double scale_y) {
    ghostty_surface_set_content_scale(surface, scale_x, scale_y);
}

void cleanup() {
    // Free surfaces
    ghostty_surface_free(surface);
    
    // Free app
    ghostty_app_free(app);
    
    // Free config
    ghostty_config_free(config);
}