> ## Documentation Index
> Fetch the complete documentation index at: https://abxbus.archivebox.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Get started quickly with abxbus in Python, TypeScript, Rust, or Go.

Install abxbus, define one typed event, register a handler, and emit the event. Rust and Go support is currently alpha while cross-runtime parity coverage continues to expand.

Repository example files:

* [`examples/simple.py`](https://github.com/ArchiveBox/abxbus/blob/main/examples/simple.py)
* [`abxbus-ts/examples/simple.ts`](https://github.com/ArchiveBox/abxbus/blob/main/abxbus-ts/examples/simple.ts)
* [`abxbus-rust/README.md`](https://github.com/ArchiveBox/abxbus/blob/main/abxbus-rust/README.md)
* [`abxbus-go/README.md`](https://github.com/ArchiveBox/abxbus/blob/main/abxbus-go/README.md)

## Install

<Tabs>
  <Tab title="Python">
    ```bash theme={null}
    pip install abxbus
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash theme={null}
    npm install abxbus
    ```
  </Tab>

  <Tab title="Rust">
    ```bash theme={null}
    cargo test --manifest-path abxbus-rust/Cargo.toml
    ```
  </Tab>

  <Tab title="Go">
    ```bash theme={null}
    go get github.com/ArchiveBox/abxbus/abxbus-go
    ```
  </Tab>
</Tabs>

## First event

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    import asyncio
    from abxbus import BaseEvent, EventBus

    class CreateUserEvent(BaseEvent[dict]):
        email: str

    async def on_create_user(event: CreateUserEvent) -> dict:
        user = await your_create_user_logic(event.email)
        return {'user_id': user['id']}

    async def main() -> None:
        bus = EventBus('MyAuthEventBus')
        bus.on(CreateUserEvent, on_create_user)

        event = await bus.emit(CreateUserEvent(email='someuser@example.com')).now()
        result = await event.event_result()
        print(result)
        # {'user_id': 'some-user-uuid'}

    asyncio.run(main())
    ```
  </Tab>

  <Tab title="TypeScript">
    ```ts theme={null}
    import { BaseEvent, EventBus } from 'abxbus'
    import { z } from 'zod'

    const CreateUserEvent = BaseEvent.extend('CreateUserEvent', {
      email: z.string(),
      event_result_type: z.object({ user_id: z.string() }),
    })

    const bus = new EventBus('MyAuthEventBus')

    bus.on(CreateUserEvent, async (event) => {
      const user = await yourCreateUserLogic(event.email)
      return { user_id: user.id }
    })

    const event = bus.emit(CreateUserEvent({ email: 'someuser@example.com' }))
    await event.now()
    console.log(await event.eventResult()) // { user_id: 'some-user-uuid' }
    ```
  </Tab>

  <Tab title="Rust">
    ```rust theme={null}
    use abxbus::{event, event_bus::EventBus};
    use futures::executor::block_on;
    use serde_json::json;

    event! {
        struct CreateUserEvent {
            email: String,
            event_result_type: serde_json::Value,
        }
    }

    let bus = EventBus::new(Some("MyAuthEventBus".to_string()));
    bus.on(CreateUserEvent, |event: CreateUserEvent| async move {
        let email = event.email.clone();
        Ok(json!({"user_id": format!("created:{email}")}))
    });

    let event = bus.emit(CreateUserEvent {
        email: "someuser@example.com".to_string(),
        ..Default::default()
    });
    block_on(async {
        let completed = event.now().await?;
        let result = completed.event_result().await?;
        println!("{result:?}");
        Ok::<(), String>(())
    })?;
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    type CreateUserEvent struct {
    	Email string `json:"email"`
    }

    type CreateUserResult struct {
    	UserID string `json:"user_id"`
    }

    bus := abxbus.NewEventBus("MyAuthEventBus", nil)
    bus.On(func(event CreateUserEvent) (CreateUserResult, error) {
    	return CreateUserResult{UserID: "some-user-uuid"}, nil
    })

    event := bus.Emit(CreateUserEvent{Email: "someuser@example.com"})
    result, err := event.EventResult()
    if err != nil {
    	panic(err)
    }
    fmt.Println(result)
    ```
  </Tab>
</Tabs>

## Next steps

* Browse the [Features](./features/event-pattern-matching) section for behavior patterns.
* Use [API Reference](./api/eventbus) for signatures and options.
* See [Integrations](./integrations/bridges) for bridges and middleware.