> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/sammwyy/mikuMikuBeam/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQ

> Frequently asked questions about Miku Miku Beam

## General Questions

<AccordionGroup>
  <Accordion title="What operating systems does Miku Miku Beam support?">
    MMB supports multiple operating systems:

    * **Windows**
    * **Linux**
    * **macOS**
    * **Android** (untested)

    The tool is written in Go and React, making it highly portable across platforms.
  </Accordion>

  <Accordion title="What is Miku Miku Beam?">
    Miku Miku Beam is a network stress testing tool with a Miku-themed frontend. It allows you to configure and run various types of network attacks while enjoying a vibrant, anime-inspired interface complete with background music.

    **Key Features:**

    * Multiple attack methods (HTTP Flood, HTTP Bypass, Slowloris, TCP Flood, Minecraft Ping)
    * Real-time attack visualization and statistics
    * Both web interface and CLI support
    * Multi-threaded performance
    * Proxy support for anonymity
  </Accordion>

  <Accordion title="Is this tool legal to use?">
    <Warning>
      Miku Miku Beam is for **educational purposes only**. Using this tool to attack systems without explicit permission is illegal and unethical.
    </Warning>

    Legal uses include:

    * Testing your own infrastructure
    * Authorized penetration testing
    * Educational research with proper authorization
    * Load testing your own applications

    Always ensure you have written permission before testing any system you don't own.
  </Accordion>
</AccordionGroup>

## Setup and Installation

<AccordionGroup>
  <Accordion title="What are the prerequisites for running MMB?">
    You need the following installed:

    <Steps>
      <Step title="Go (v1.21 or above)">
        Required for building the server and CLI binaries.

        ```bash theme={null}
        go version
        ```
      </Step>

      <Step title="Node.js (v18 or above)">
        Required for building the React frontend.

        ```bash theme={null}
        node --version
        ```
      </Step>

      <Step title="npm (Node Package Manager)">
        Comes bundled with Node.js.

        ```bash theme={null}
        npm --version
        ```
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="I go to http://localhost:3000 and nothing appears">
    This means the web client hasn't been built yet.

    **Solution:**

    1. Build the web client:
       ```bash theme={null}
       make webclient
       ```
    2. Ensure the server is running:
       ```bash theme={null}
       ./bin/mmb-server
       ```
    3. If issues persist, rebuild everything:
       ```bash theme={null}
       make all && make run-server
       ```

    <Note>
      The web client must be built before the server can serve it. In production mode, both frontend and backend run on port 3000.
    </Note>
  </Accordion>

  <Accordion title="It crashes on startup with a 'concurrently' error">
    This is a Node.js/React build issue.

    **Solution:**

    1. Verify Node.js version (must be v18+):
       ```bash theme={null}
       node --version
       ```
    2. Reinstall dependencies:
       ```bash theme={null}
       cd web-client
       npm install
       cd ..
       ```
    3. Run the prepare command:
       ```bash theme={null}
       make prepare
       ```
  </Accordion>

  <Accordion title="Build fails with 'module not found' errors">
    Dependencies aren't installed or are out of sync.

    **Solution:**

    1. Download Go dependencies:
       ```bash theme={null}
       go mod tidy
       ```
    2. Install Node.js dependencies:
       ```bash theme={null}
       cd web-client && npm install
       ```
    3. Or use the all-in-one command:
       ```bash theme={null}
       make prepare
       ```
  </Accordion>
</AccordionGroup>

## Usage Questions

<AccordionGroup>
  <Accordion title="How do I run attacks without proxies?">
    By default, MMB requires proxies for safety. However, you can bypass this:

    **CLI Method:**

    ```bash theme={null}
    ./bin/mmb-cli attack http_flood http://example.com --no-proxy
    ```

    **Server Method:**
    Set the environment variable before starting:

    ```bash theme={null}
    ALLOW_NO_PROXY=true ./bin/mmb-server
    ```

    <Warning>
      Running without proxies exposes your real IP address to the target.
    </Warning>
  </Accordion>

  <Accordion title="Can I run multiple attacks simultaneously?">
    Yes! MMB supports running multiple attacks at the same time.

    **Web Interface:**

    * Open multiple browser tabs/windows
    * Each tab can run a different attack
    * Each client maintains its own isolated attack instance

    **CLI:**

    * Run multiple CLI instances in different terminals
    * Each instance operates independently
  </Accordion>

  <Accordion title="What attack methods are available?">
    MMB currently supports five attack methods:

    <CardGroup cols={2}>
      <Card title="HTTP Flood" icon="water">
        Sends random HTTP GET/POST requests with configurable payloads to overwhelm the target.
      </Card>

      <Card title="HTTP Bypass" icon="shield-halved">
        Mimics real browser requests with realistic headers, cookies, redirects, and resource loading.
      </Card>

      <Card title="HTTP Slowloris" icon="hourglass">
        Sends slow HTTP requests and keeps connections open to exhaust server resources.
      </Card>

      <Card title="TCP Flood" icon="network-wired">
        Raw TCP packet flooding with random data to saturate network connections.
      </Card>

      <Card title="Minecraft Ping" icon="gamepad">
        Sends Minecraft server status/MOTD requests to stress game servers.
      </Card>
    </CardGroup>
  </Accordion>

  <Accordion title="How do I add proxies and user agents?">
    You can manage proxies and user agents in two ways:

    **Method 1: Web Interface**

    * Click the text button to the right of the beam button
    * This opens the editor where you can add/edit proxies and user agents

    **Method 2: Manual File Editing**
    Create/edit these files:

    ```bash theme={null}
    # Proxies (one per line)
    data/proxies.txt
    ```

    Supported proxy formats:

    * `protocol://user:password@host:port` (with authentication)
    * `protocol://host:port`
    * `host:port` (defaults to http)
    * `host` (defaults to port 8080)

    ```bash theme={null}
    # User agents (one per line)
    data/uas.txt
    ```
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Requests fail to be sent with timeout errors">
    This typically indicates proxy issues.

    **Solution:**

    1. Add valid proxies to `data/proxies.txt`
    2. Ensure proxies are in the correct format:
       * `protocol://user:password@host:port`
       * `protocol://host:port`
       * `host:port`
       * `host`
    3. Or run without proxies using the `--no-proxy` flag

    See the [troubleshooting guide](/troubleshooting) for more details.
  </Accordion>

  <Accordion title="CLI shows 'No proxies available' error">
    **Quick Fix:**

    ```bash theme={null}
    # Add proxies to the file
    echo "http://proxy1:8080" >> data/proxies.txt
    ```

    Or run without proxies:

    ```bash theme={null}
    ./bin/mmb-cli attack http_flood http://example.com --no-proxy
    ```
  </Accordion>

  <Accordion title="The web client doesn't load or shows errors">
    The React frontend wasn't built correctly.

    **Solution:**

    ```bash theme={null}
    # Clean and rebuild
    make clean
    make all
    ```

    Check the [troubleshooting guide](/troubleshooting) for detailed solutions.
  </Accordion>
</AccordionGroup>

## Advanced Usage

<AccordionGroup>
  <Accordion title="How do I customize attack parameters?">
    You can configure multiple parameters:

    **Web Interface:**

    * Target URL
    * Attack method
    * Packet size (bytes)
    * Duration (seconds)
    * Packet delay (milliseconds)
    * Thread count

    **CLI Example:**

    ```bash theme={null}
    ./bin/mmb-cli attack http_bypass http://example.com \
      --duration 120 \
      --delay 100 \
      --packet-size 1024 \
      --threads 8
    ```
  </Accordion>

  <Accordion title="How do I enable verbose logging?">
    Use the `--verbose` flag in the CLI to see detailed attack logs:

    ```bash theme={null}
    ./bin/mmb-cli attack tcp_flood http://example.com --verbose
    ```

    This shows:

    * Which proxy is being used for each request
    * Target information
    * Detailed success/failure logs
    * Real-time statistics
  </Accordion>

  <Accordion title="How can I contribute or add new attack methods?">
    MMB is open source and welcomes contributions!

    **To add a new attack method:**

    <Steps>
      <Step title="Create worker file">
        Create a new attack worker in `internal/attacks/your_protocol/`

        ```go theme={null}
        type yourWorker struct{}
        func NewYourWorker() *yourWorker { return &yourWorker{} }
        func (w *yourWorker) Fire(ctx context.Context, params core.AttackParams, p core.Proxy, ua string, logCh chan<- core.AttackStats) error {
            // Implementation
            return nil
        }
        ```
      </Step>

      <Step title="Register in engine">
        Add to `internal/engine/registry.go`:

        ```go theme={null}
        AttackYourProtocol: yourprotocol.NewYourWorker(),
        ```
      </Step>

      <Step title="Update web client">
        Add the new method to the web interface attack list.
      </Step>
    </Steps>

    See the [Contributing](/development/contributing) guide for more details.
  </Accordion>
</AccordionGroup>

## Docker and Deployment

<AccordionGroup>
  <Accordion title="Can I run MMB in Docker?">
    Yes! MMB is Docker-ready.

    <Note>
      Docker support is built-in. Check the documentation for Docker-specific deployment instructions.
    </Note>
  </Accordion>

  <Accordion title="What's the difference between development and production mode?">
    **Development Mode:**

    * Frontend and backend run on separate ports
    * Hot-reload enabled for development
    * Run with `make run-server`

    **Production Mode:**

    * Both frontend and backend served on port 3000
    * Optimized builds
    * Run with `./bin/mmb-server`
  </Accordion>
</AccordionGroup>

<Note>
  Don't see your question here? Check the [troubleshooting guide](/troubleshooting) or open an issue on [GitHub](https://github.com/sammwyy/mikumikubeam/issues).
</Note>