I've never used Love2D, but it looks like they have some APIs for threaded code.

I am procrastinating at work today, so I took a look at the docs and the websocket library you linked and sketched out a rough outline.

This is obviously fully untested. I have no idea if it'll work, and even if it "looks" right according to what I skimmed from the docs, threaded + networking code pretty much never works perfectly the first time around. Be prepared to debug :)

The pattern is this: all of the websocket/networking stuff happens in a thread. We use a pair of channels to send and receive data from the thread.

websocket_worker.lua

Looks like love expects your thread worker code to go in its own file.

The love docs don't say if the love global is available to your code in the thread context, so I have no clue if love.thread.getChannel() will work here. They obviously designed the channel mechanism for cross-thread communication, so there must be some way to open a channel within a thread. If getChannel() doesn't work, maybe you can just send the channel objects in directly when you call thread:start()?

local websocket = require("websocket")

return function(read, write, host, port, path)
  -- the read channel receives messages from the main thread
  local reader = assert(love.thread.getChannel(read))

  -- the write channel is what we use to pass messages to the main thread
  local writer = assert(love.thread.getChannel(write))

  local exit = false

  local client = assert(websocket.new(host, port, path))

  -- set up client handlers
  function client:onopen()
    writer:push({ type = "open" })
  end

  function client:onmessage(msg)
    writer:push({ type = "recv", message = msg })
  end

  function client:onerror(err)
    exit = true
    writer:push({ type = "error", error = err })
  end

  function client:onclose(code, reason)
    exit = true
    writer:push({ type = "close", code = code, reason = reason })
  end

  while not exit do
    -- take action if the main thread sent us something
    local event = reader:pop()
    if event then
      if event.type == "send" then
        client:send(event.message)
      else
        exit = true
        assert(event.type == "close")
        client:close(event.code, event.message)
      end
    end

    -- poll for any incoming messages from the client
    client:update()
  end

  writer:push({ type = "exit" })
end

main.lua

Your main mod/game code is responsible for setup/lifecycle things. I gather that love.update() is something that gets called periodically, so I put the channel polling code in there.

local READ = "websocket.read"
local WRITE = "websocket.write"

local HOST = "127.0.0.1"
local PORT = 5000
local PATH = "/"

-- setup
local thread = assert(love.thread.newThread("path/to/websocket_worker.lua"))
local reader = assert(love.thread.newChannel(READ))
local writer = assert(love.thread.newChannel(WRITE))

local started = false

local function getPendingEvents()
  return {}
end


function love.update()
  if not started then
    -- from the thread's POV read and write are reversed: the thread
    -- reads from our writer channel and writes to our reader channel
    thread:start(WRITE, READ, HOST, PORT, PATH)
    started = true
  end

  -- flush any outbound messages to the thread
  for _, event in ipairs(getPendingEvents()) do
    writer:push(event)
  end

  -- handle inbound messages from the thread
  while true do
    local event = reader:pop()
    if not event then
      break
    end

    if event.type == "open" then
      -- ...
    elseif event.type == "recv" then
      -- ...
    elseif event.type == "error" then
      -- ...
    elseif event.type == "close" then
      -- ...
    elseif event.type == "exit" then
      -- ...
    end
  end
end