[Feature]: Support for Elixir Workers (BEAM VM)

[ElioNeto]

Problem Statement

vyx currently orchestrates backends written in Go, Node.js, and Python. While these cover a wide range of use cases, we are missing out on the BEAM VM ecosystem. Many engineering teams are moving to Elixir for their worker/agent layers due to its massively stable, lightweight concurrency, and fault-tolerant OTP architecture. Currently, there is no native way to integrate an Elixir backend into the vyx IPC/UDS ecosystem.

Proposed Solution

Develop a native Elixir worker binding for vyx.

Since vyx decouples the edge/gateway layer from the business logic, the Go Core Orchestrator would continue to handle raw networking, JWT verification, and malicious payload filtering. It would then pass clean, validated requests down to the Elixir worker via Unix Domain Sockets (UDS).

To achieve this, we need:

1. An Elixir library/module capable of reading the vyx binary protocol (and MsgPack/Apache Arrow) over UDS.
2. A build-time scanner or Elixir Macros to generate the route_map.json based on Elixir module attributes (equivalent to our current annotation-based routing).

Alternatives Considered

• Standard HTTP/TCP microservices: We could allow the Go core to proxy requests to an Elixir app via standard HTTP, but this defeats the vyx guiding principle of low-latency IPC using UDS and zero-copy/minimal overhead data transfer.
• Sticking only to Go/Node/Python: While powerful, none of these languages offer the exact same supervision tree (OTP) and stateful concurrency model out-of-the-box that Elixir provides.

Use Case

Developers who want to build highly concurrent, fault-tolerant business logic, real-time features, or distributed state applications can write their workers in Elixir, while offloading brute-force edge security, routing, and schema validation to the high-performance Go Core.

# Example of how an Elixir worker might look using module attributes (macros) in vyx:

defmodule MyApp.Workers.Billing do
  use Vyx.Worker

  @route "POST /api/billing/process"
  @validate "billing_schema"
  @auth roles: ["admin"]
  def process_billing(request) do
    # At this point, the Go Core has already validated the JWT 
    # and ensured the payload matches the 'billing_schema'.
    # We just handle the business logic using Elixir's concurrency!
    
    {:ok, %{status: "processed", id: 123}}
  end
end

Additional Context

This feature was suggested by the community on Reddit.

Call for Contributors:
To be completely transparent, my day-to-day experience with Elixir is limited. I am opening this issue to put it on the roadmap and invite the community to collaborate. If anyone is passionate about Elixir and wants to take a stab at building the Elixir worker SDK, I would be absolutely thrilled to pair up and help wire up the Go Core side!

Let's make the Go + Elixir dream combo happen. 🚀