DEV Community: spechshop

SpechPhone: softphone com chamadas inbound, chat SIP e bridge RTP ↔ PCM em PHP + Swoole na Web

spechshop — Fri, 08 May 2026 09:04:16 +0000

Olá, comunidade!

Há um tempo eu publiquei aqui no DEV um artigo apresentando o SpechPhone, um softphone SIP web open-source feito com PHP, Swoole e WebSockets, com uma proposta meio fora da curva:

criar um softphone web sem depender de WebRTC.

Na primeira versão, o foco estava em provar que era possível fazer chamadas SIP pelo navegador usando um backend PHP assíncrono, controlando sinalização SIP, áudio PCM e transporte em tempo real com Swoole.

Agora o projeto deu um salto importante.

O SpechPhone deixou de ser apenas uma demonstração de discagem web e passou a caminhar para uma arquitetura mais completa de softphone SIP, com:

recebimento de chamadas inbound;
controle de estado em tempo real;
bridge de mídia RTP ↔ PCM;
suporte a SIP MESSAGE;
interface de chat integrada;
melhorias no áudio via WebSocket;
controle de volume dinâmico;
arquitetura mais limpa para chamadas ativas.

E o mais importante: ainda sem WebRTC no caminho da mídia.

Repositório:

https://github.com/spechshop/spechphone

O que mudou nesta nova fase?

A primeira versão do SpechPhone já conseguia iniciar chamadas, registrar conta SIP, configurar codec e transportar áudio entre o navegador e o backend.

Mas ainda faltava uma parte essencial para um softphone de verdade:

receber chamadas.

Nesta atualização, a branch inbound introduz um fluxo mais completo para chamadas recebidas, incluindo tratamento de INVITE, ACK, CANCEL e BYE.

Isso muda bastante a natureza do projeto.

Antes ele era um discador web experimental.

Agora ele começa a se comportar como um endpoint SIP real.

Recebimento de chamadas inbound

O fluxo inbound funciona mais ou menos assim:

O usuário configura e registra sua conta SIP no SpechPhone.
O server.php escuta SIP via UDP na porta 4000.
Quando chega um INVITE, o backend identifica o usuário de destino.
O navegador recebe um evento em tempo real informando a chamada recebida.
Ao aceitar, o servidor responde com 200 OK contendo SDP local.
A mídia RTP é ligada à ponte interna RTP ↔ PCM.
O áudio chega ao navegador via WebSocket.
Ao desligar, BYE/CANCEL limpam o estado da chamada.

Em termos práticos, o SpechPhone agora consegue tocar no navegador quando uma chamada SIP chega.

Pequeno detalhe técnico: isso parece simples escrito em oito linhas, mas no mundo SIP cada header tem autoestima própria. Se errar To-tag, Call-ID, CSeq ou rota reversa, o softphone vira decoração digital.

CallState: estado compartilhado com Swoole Table

Uma das mudanças importantes foi a introdução de um gerenciador de estado para chamadas.

O SpechPhone agora usa estruturas em memória com Swoole Table para rastrear:

chamadas recebidas;
chamadas ativas;
bindings SIP;
usuário SIP associado ao navegador;
IP/porta RTP remoto;
codec negociado;
worker dono da chamada;
status da sessão.

A ideia é simples: em um servidor assíncrono, principalmente com múltiplos workers, não dá para depender só de variável local solta no vento.

O CallState vira uma espécie de “quadro branco compartilhado” do runtime.

Ele mantém informações como:

CallState::$incomingCalls;
CallState::$activeCalls;
CallState::$sipBindings;

Isso permite que handlers diferentes saibam se existe uma chamada tocando, se ela já foi aceita, qual usuário pertence àquela chamada e como encerrar tudo corretamente.

Esse tipo de controle é essencial para eventos como:

aceitar chamada;
rejeitar chamada;
desligar;
receber BYE;
lidar com timeout RTP;
sincronizar múltiplas abas abertas no navegador.

Bridge RTP ↔ PCM: o coração da mídia

A parte mais interessante continua sendo a mídia.

O SpechPhone não envia RTP diretamente para o navegador e não depende do WebRTC para negociar ICE, STUN, TURN ou DTLS-SRTP.

A arquitetura segue outro caminho:

SIP/RTP peer
    ↓
RTP UDP
    ↓
PHP + Swoole + libspech
    ↓
PCM interno
    ↓
WebSocket de áudio
    ↓
Browser

E o caminho inverso também existe:

Microfone do navegador
    ↓
PCM via WebSocket
    ↓
audio.php
    ↓
UDP interno
    ↓
encode para codec SIP
    ↓
RTP para o peer remoto

A classe CallMediaBridge centraliza boa parte desse fluxo.

Ela cria um socket UDP local para conversar com o audio.php, registra callbacks para receber PCM decodificado e inicia corrotinas para o caminho:

RTP → decode → PCM → navegador;
navegador → PCM → encode → RTP.

Essa separação deixa a arquitetura mais clara: o plano SIP não precisa carregar toda a responsabilidade da mídia nas costas.

audio.php como servidor dedicado de áudio

Outra decisão arquitetural importante foi manter o audio.php como servidor dedicado para a ponte de áudio.

Ele atua como ponto intermediário entre:

WebSocket do navegador;
UDP interno;
chamadas ativas;
buffers PCM;
frequência de áudio;
controle de reconexão.

Na prática, isso ajuda a isolar a mídia da sinalização.

O server.php cuida do HTTP/WSS/SIP/control plane.

O audio.php cuida da parte mais ingrata: áudio em tempo real.

É aquela divisão saudável: um cuida do drama SIP, o outro cuida do chiado existencial do PCM.

Codecs suportados

O SpechPhone continua com foco em controle direto dos codecs.

A depender do ambiente e das extensões disponíveis, o projeto trabalha com:

PCMA;
PCMU;
G.729;
L16;
Opus;
telephone-event / DTMF RFC2833.

A negociação usa SDP remoto para escolher o codec compatível e gerar uma resposta local.

A vantagem dessa abordagem é ter controle total do pipeline.

O navegador não precisa suportar o codec SIP do tronco. Ele pode trabalhar com PCM, enquanto o backend faz a conversão necessária para o mundo VoIP.

Isso abre espaço para integrações mais avançadas no futuro, como:

gravação;
transcrição;
VAD;
agente de voz;
análise de áudio;
filtros;
mixagem;
monitoramento de volume;
detecção de fala.

SIP MESSAGE e chat integrado

Outra novidade forte é o suporte a mensagens SIP.

O SpechPhone agora tem um caminho integrado para envio e recebimento de mensagens de texto usando MESSAGE.

No lado do backend, existe um armazenamento simples em:

/data/spechphone/messages.json

Ele mantém:

conversas;
histórico;
mensagens não lidas;
participantes;
última mensagem;
eventos em tempo real.

Quando uma nova mensagem chega, o backend pode empurrar um evento WebSocket para o cliente conectado.

Isso transforma o SpechPhone em algo além de um discador.

Ele começa a virar uma interface SIP web completa: chamada + mensagem + presença futura + controle de conta.

A interface de mensagens ainda é simples, mas já cria uma base interessante para comunicação em tempo real dentro do próprio navegador.

Interface mais modular

A UI também evoluiu.

Agora o projeto organiza melhor as áreas principais:

discador;
chamadas;
mensagens;
configurações de áudio;
configuração SIP;
notificações;
timers;
medidores de sinal;
barra de chamada ativa.

Algumas capturas da nova fase:

Melhorias recentes no áudio

As versões recentes também trouxeram melhorias práticas no áudio e na experiência da chamada:

controle de volume dinâmico com GainNode;
sliders visuais para microfone e retorno;
persistência de configurações em localStorage;
melhorias no buffer PCM;
validação de codec/frequência;
controle de reconexão;
logs mais ricos no client e no server;
limpeza de conexões antigas;
redução de inconsistências em chamadas WebSocket.

Essas mudanças são menos chamativas que “agora recebe chamada”, mas são justamente o tipo de ajuste que separa demo bonita de ferramenta utilizável.

Áudio em tempo real é cruel: um buffer mal-humorado e o usuário já acha que está falando de dentro de uma lata de sardinha.

Por que não WebRTC?

Essa pergunta sempre aparece.

O SpechPhone não é uma tentativa de dizer que WebRTC é ruim.

WebRTC é excelente.

Mas ele também traz uma pilha grande:

ICE;
STUN;
TURN;
SDP próprio;
codecs controlados pelo browser;
políticas de mídia;
NAT traversal;
comportamento diferente entre navegadores;
dependências que nem sempre fazem sentido em uma infraestrutura SIP já existente.

O SpechPhone segue outra filosofia:

se o servidor já fala SIP e RTP, então o navegador pode ser apenas a interface, e o backend controla a mídia.

Isso dá mais trabalho?

Sim.

Dá mais controle?

Muito.

É uma abordagem para quem quer entender e controlar a pilha inteira, do INVITE ao pacote RTP.

Arquitetura resumida

Browser
 ├── Interface Web
 ├── WebSocket de controle
 └── WebSocket de áudio PCM
          │
          ▼
server.php
 ├── HTTPS/WSS
 ├── SIP UDP :4000
 ├── roteamento de eventos
 ├── controle de chamadas
 ├── CallState / Swoole Tables
 └── integração com libspech
          │
          ▼
audio.php
 ├── WebSocket de áudio
 ├── UDP interno :9600
 ├── buffers PCM
 ├── relay de áudio
 └── ponte com chamadas ativas
          │
          ▼
SIP/RTP peer
 ├── Asterisk
 ├── FreeSWITCH
 ├── OpenSIPS
 ├── trunk SIP
 └── provedor VoIP

Instalação básica

git clone https://github.com/spechshop/spechphone
cd spechphone

git clone https://github.com/spechshop/libspech

wget https://github.com/spechshop/pcg729/releases/download/PCG729/php
sudo mv php /usr/local/bin/php
sudo chmod +x /usr/local/bin/php

git submodule update --init --recursive

cp .env.example .env

Depois configure sua chave:

SPECH_VAULT_KEY_HEX=sua_chave_aqui

E rode os servidores:

php server.php

Em outro terminal:

php audio.php

Status do projeto

O SpechPhone ainda está em desenvolvimento ativo.

A branch inbound já é altamente funcional, mas ainda deve ser tratada como experimental para produção.

O foco agora é endurecer a base:

melhorar estabilidade inbound;
refinar tratamento de NAT;
lapidar encerramento de chamadas;
melhorar compatibilidade com PBXs;
evoluir o chat SIP;
preparar o terreno para recursos de mídia mais avançados.

Contribuições

O projeto é open-source e qualquer contribuição é bem-vinda.

Você pode ajudar com:

testes com Asterisk, FreeSWITCH, OpenSIPS e provedores SIP;
issues com logs reais;
melhorias na UI;
ajustes de compatibilidade SIP;
melhorias no buffer de áudio;
documentação;
exemplos de configuração;
testes de codecs.

Repositório:

https://github.com/spechshop/spechphone

Se o projeto te interessar, uma estrela no GitHub também ajuda bastante.

Open-source vive de código, café e pequenas doses de validação social. Principalmente café.

Conclusão

O SpechPhone começou como uma provocação técnica:

será que dá para fazer um softphone SIP web em PHP, com Swoole, sem WebRTC?

A resposta inicial foi: sim, dá.

Agora a nova pergunta é outra:

dá para transformar isso em um softphone web SIP realmente utilizável?

Com chamadas inbound, bridge RTP ↔ PCM, controle de estado, áudio em tempo real e SIP MESSAGE integrado, o projeto chegou em uma fase muito mais interessante.

Ainda tem chão pela frente, mas a base ficou mais séria.

E, sinceramente, ver PHP segurando SIP, RTP, PCM, WebSocket e chat em tempo real no mesmo ecossistema é aquele tipo de insanidade técnica que dá gosto de construir.

Até a próxima atualização.

SpechPhone: Softphone SIP Web com PHP (Swoole) e WebSockets 🚀

spechshop — Tue, 06 Jan 2026 10:01:01 +0000

Olá, comunidade! 👋

Estou animado para compartilhar o status atual do SpechPhone, um softphone SIP web open-source que desafia o convencional ao não utilizar WebRTC. Em vez disso, utilizamos o poder do PHP com Swoole no backend para processamento de mídia em tempo real e WebSockets para o transporte de áudio PCM.

O projeto está evoluindo rapidamente e gostaria de mostrar como está a interface e as funcionalidades disponíveis hoje.

📱 Interface Principal (Dialer)

A interface de chamada foi projetada para ser intuitiva e responsiva. Temos um discador completo com feedback visual, controles de volume independentes para microfone e retorno de áudio, além de indicadores de nível de sinal (VU meters).

Tela principal: Discador, controles de chamada e monitoramento de áudio.

Bastidores Técnicos:
O front-end interage com handlers específicos para gerenciar o estado da chamada:

startCall.php: Ao discar, este handler cria uma corrotina Swoole dedicada que gerencia toda a sinalização SIP (INVITE) e aloca portas UDP dinâmicas para o RTP.

checkCall.php: Atua como um heartbeat, sincronizando o status da UI (timer, botões) com a corrotina no backend.

dtmf.php: O envio de tons utiliza o padrão RFC 2833, injetando eventos diretamente no stream RTP via PHP.

hangUpCall.php: Garante o encerramento limpo (BYE) e a liberação imediata dos recursos de áudio.

📄 plugins/Message/handlers/startCall.php:44
public static function resolve(Server $socket, array $model, int $fd): ?bool
{
   $data = $model['data'];
   $vault = new \spechphoneVault('/data/spechphone/devices.vault', getenv('SPECH_VAULT_KEY_HEX'));
   // ...

🎧 Suporte Avançado a Codecs

Uma das grandes vantagens da nossa arquitetura é o controle total sobre a transcodificação. O SpechPhone suporta nativamente uma grande variedade de codecs, processados diretamente no backend PHP.

Na aba de Áudio, é possível visualizar e selecionar os codecs disponíveis:

G.729 & Opus: Para alta compressão e qualidade.
PCMA/PCMU: Padrões clássicos G.711.
Wideband: G.722, Speex, L16 (até 48kHz).
GSM & iLBC: Para cenários de banda estreita.

Painel de Codecs: No final todos se tornarão PCM devolvido para o browser.

Bastidores Técnicos:
A mágica acontece na integração entre o startCall.php e o servidor de áudio audio.php:

Pipeline de Áudio (Sem WebRTC): O navegador envia/recebe PCM raw via WebSocket (porta 8888) para o audio.php.

Bridge UDP: O audio.php encaminha esse áudio via UDP local (porta 9600) para a corrotina da chamada.

Transcoding Nativo: O PHP recebe o PCM, aplica a codificação selecionada (ex: comprime para G.729 ou Opus) usando a biblioteca libspech e envia para o tronco SIP. O processo inverso (decodificação) ocorre na chegada dos pacotes RTP, garantindo compatibilidade universal sem depender de codecs do browser.

📄 audio.php:54
$udp = new Swoole\Coroutine\Socket(AF_INET, SOCK_DGRAM, 0);
$udp->bind("0.0.0.0", 9600);
echo "🎧 Servidor UDP aguardando pacotes em 9600...\n";

⚙️ Configuração SIP Simplificada

Conectar-se ao seu servidor VoIP (Asterisk, FreeSWITCH, Opensips) é simples. A tela de configurações permite definir o servidor, credenciais de autenticação e o codec preferencial para o tronco SIP.

Configuração da conta SIP e preferências de conexão.

Bastidores Técnicos:
A segurança e a validação são prioridades no handler saveConfig.php:

Validação Ativa: Antes de salvar, o sistema instancia um trunkController e tenta realizar um registro real (SIP REGISTER) no servidor.

Feedback Imediato: Se as credenciais estiverem erradas, o usuário é notificado na hora, evitando configurações "quebradas".

Persistência Segura: Apenas após o sucesso (200 OK), os dados são criptografados e armazenados no devices.vault. O handler register.php pode então ser usado para manter a sessão ativa (keep-alive).

📄 plugins/Message/handlers/saveConfig.php:103
if (!$trunkController->register(5)) {
   return $socket->push($fd, json_encode([
       'type' => 'notify',
       'data' => [
           'type' => 'bg-danger text-white',
           'message' => "Registro falhou, verifique as credenciais fornecidas"
       ]
   ]));
}

O projeto está em fase Beta e o desenvolvimento continua ativo, focado agora em aprimorar a estabilidade e implementar o recebimento de chamadas.

🔗 Confira o código e contribua no GitHub: https://github.com/spechshop/spechphone

Fiquem ligados para mais novidades! 🚀

VOIP Calls + Resample + PHP

spechshop — Sun, 04 Jan 2026 04:17:39 +0000

VoIP Real-Time e Áudio 48 kHz no PHP: Guia Hands-On com Swoole

Este guia demonstra como construir um softphone completo com áudio de alta qualidade (48 kHz) usando PHP moderno com Swoole. Vamos explorar VoIP e processamento de áudio em tempo real através de uma implementação prática.

Nota importante sobre arquitetura: O SpechPhone que vamos explorar funciona de um jeito diferente do que você talvez esteja acostumado. Aqui, subimos dois servidores PHP (middleware.php e audio.php) que entregam áudio via RTP no backend + WebSocket (PCM) pro browser — sem passar pelo caminho tradicional do Asterisk/AGI. É uma abordagem mais direta que facilita a compreensão do fluxo completo.
Referência: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

O que você vai construir (de verdade)

Ao final deste guia, você terá nas mãos:

Um softphone web funcional que faz SIP/RTP em tempo real, com interface no browser via WebSocket
Um pipeline de mídia completo onde o backend recebe RTP, decodifica e envia PCM em chunks pro cliente
Uma implementação prática de I/O assíncrono com corrotinas por sessão

E o melhor: você vai entender cada peça desse quebra-cabeça.

1) Entendendo a arquitetura

Vamos começar pelo básico: como tudo isso se encaixa? O SpechPhone é construído sobre PHP + Swoole, trabalhando com mídia em RTP/UDP no backend e PCM via WebSocket direto pro browser. Nada de WebRTC/SRTP/ICE/DTLS aqui — é uma abordagem mais crua e direta, o que facilita muito pra entender o que está acontecendo em cada camada.

Referência: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

Os dois pilares da aplicação:

middleware.php: servidor HTTP/WebSocket para interface web e controle de chamadas + servidor UDP para sinalização SIP
audio.php: servidor HTTP/WebSocket + UDP que recebe streams RTP decodificados, mixa múltiplos canais de áudio e distribui via WebSocket para os clientes

Cada um tem seu papel bem definido, e você vai ver como eles conversam entre si.

Referência: https://github.com/spechshop/spechphone (seção "Directory Structure" do README)

2) O segredo do Swoole: corrotinas e I/O assíncrono

O conceito fundamental aqui é I/O assíncrono com corrotinas. Independente da linguagem, quando você domina esse padrão, consegue lidar com operações em tempo real de forma eficiente.

O SpechPhone abre uma coroutine dedicada pra cada trunkController, o que significa que você pode ter várias chamadas simultâneas rodando sem bloquear o processo principal. É a aplicação prática de concorrência cooperativa — um padrão que funciona em qualquer ecossistema que o implemente.

Referência: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

Detalhe importante: Estamos falando de Swoole (a extensão/runtime oficial), não OpenSwoole. São projetos diferentes, então fique atento na hora de instalar.

3) Mão na massa: subir o SpechPhone localmente

Hora de colocar a mão no teclado. O README do SpechPhone já entrega tudo mastigado: clone, instale o runtime e suba os servidores. Simples assim.

# deps
sudo apt update && sudo apt install -y openssl

# repo + lib
git clone https://github.com/spechshop/spechphone && cd spechphone
git clone https://github.com/spechshop/libspech

# runtime php otimizado (pcg729)
curl -L https://github.com/spechshop/pcg729/releases/download/current/php -o php
chmod +x ./php
sudo cp php /usr/local/bin/php

# start (em terminais separados)
php middleware.php
php audio.php

Referência do trecho acima: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

Dica prática: Abra dois terminais lado a lado. Deixe os logs rolando e observe como os servidores se comunicam. É bem instrutivo ver o fluxo acontecendo em tempo real.

4) Áudio 48 kHz: onde entra (de verdade) e por que isso importa

Aqui é onde a coisa fica interessante. Quando falamos de telefonia tradicional, você está preso a 8 kHz (aquele som meio "de telefone", sabe?). Mas com Opus a 48 kHz, você tem qualidade de áudio próxima do que ouve em streaming de música. É uma diferença que você sente na primeira chamada.

O SpechPhone trabalha com duas peças que se complementam:

1) Oferta de Opus/48kHz via SDP no trunkController (libspech). É aqui que você diz pro outro lado: "ei, eu falo Opus em alta qualidade":

// Oferecer codec Opus em SDP
$phone->mountLineCodecSDP('opus/48000/2');

Referência do snippet: https://github.com/spechshop/libspech/blob/spech/README.md

2) Decodificação dinâmica + PCM em chunks pro browser. Os pacotes RTP chegam, são processados pela libspech (usando funções nativas via runtime pcg729), e o áudio decodificado é entregue ao controlador WebSocket em PCM puro, pronto pra ser consumido no browser via webkitAudioContext.

Referência: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

Em outras palavras: você negocia Opus, recebe RTP, decodifica e entrega PCM. Simples, direto e poderoso.

5) Um exemplo mínimo de chamada — vendo corrotinas e eventos na prática

Esse é o "hello world" da stack. Aqui você registra no servidor SIP, oferece o codec, reage a eventos (tocando, atendido, desligado) e recebe áudio. Tudo isso em menos de 50 linhas:

<?php
use libspech\Sip\trunkController;

include 'plugins/autoloader.php';

\Swoole\Coroutine\run(function () {
    $username = getenv('SIP_USERNAME');
    $password = getenv('SIP_PASSWORD');
    $domain   = getenv('SIP_DOMAIN');
    $host     = gethostbyname($domain);

    $phone = new trunkController($username, $password, $host, 5060);

    if (!$phone->register(2)) {
        throw new \Exception('Falha no registro');
    }

    // Oferecer codec Opus em SDP (48 kHz)
    $phone->mountLineCodecSDP('opus/48000/2');

    $phone->onRinging(function ($phone) {
        echo "Tocando...\n";
    });

    $phone->onAnswer(function (trunkController $phone) {
        echo "Atendido. Recebendo mídia...\n";
        $phone->receiveMedia();
        \Swoole\Coroutine::sleep(10);
    });

    $phone->onReceiveAudio(function ($pcmData, $peer, trunkController $phone) {
        echo "Recebido: " . strlen($pcmData) . " bytes\n";
    });

    $phone->onHangup(function (trunkController $phone) {
        echo "Chamada finalizada\n";
        $phone->close();
    });

    $phone->call('5511999999999');
});

Referência (onde esse exemplo está documentado): https://github.com/spechshop/libspech/blob/spech/README.md

Referência do exemplo completo: https://github.com/spechshop/libspech/blob/spech/example.php

O que está acontecendo aqui? Você registra no servidor SIP, configura callbacks pra cada evento da chamada (ringing, answer, hangup) e, quando atendido, começa a receber chunks de áudio PCM. Cada callback roda na sua própria coroutine, sem travar nada.

6) Três exercícios práticos (pra você realmente aprender fazendo)

Ler código é legal, mas mexer nele é melhor. Aqui vão três experimentos rápidos pra você sentir como tudo funciona:

1) Troque o codec e compare

Mude opus/48000/2 para L16/8000 (o README do libspech também menciona L16/8000) e compare o que você recebe em onReceiveAudio. Você vai notar diferença no tamanho dos chunks e na qualidade do áudio.
Referência: https://github.com/spechshop/libspech/blob/spech/README.md

2) Instrumente o fluxo de PCM

Deixe o log de strlen($pcmData) rodando e observe os padrões: tamanho dos chunks, frequência de chegada, variações (jitter aparente). É fascinante ver como o áudio flui em tempo real.
Referência: https://github.com/spechshop/libspech/blob/spech/README.md

3) Faça a UI reagir aos eventos

O SpechPhone usa um cliente "thin" via WebSocket. Faça o frontend reagir aos eventos "ringing/answered/hangup" que vêm do backend. Comece simples: apenas logando na tela. Depois você pode adicionar animações, indicadores visuais, etc.
Referência: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

Links principais (pra você não se perder)

Aqui estão todos os recursos que você vai precisar:

SpechPhone (repo): https://github.com/spechshop/spechphone
SpechPhone (README, branch volume-dev): https://github.com/spechshop/spechphone/blob/volume-dev/README.md
libspech (repo): https://github.com/spechshop/libspech
libspech (README, branch spech): https://github.com/spechshop/libspech/blob/spech/README.md
libspech (example.php): https://github.com/spechshop/libspech/blob/spech/example.php
pcg729 (runtime release "current/php"): https://github.com/spechshop/pcg729/releases/tag/current

E agora? Clone o repo, suba os servidores e faça sua primeira chamada. Os conceitos apresentados aqui são aplicáveis a qualquer stack que implemente I/O assíncrono com corrotinas. Boa sorte! 🚀