Nota do autor: usando o Qwen3.5-4B-GLB-3D-Coder como exemplo, destrinchamos o fluxo de trabalho da camada intermediária de código “texto → Three.js → GLB” e apresentamos etapas práticas para colocar tudo em produção.
Fazer um Modelo de Linguagem Grande gerar diretamente arquivos 3D utilizáveis é um desafio que muitos desenvolvedores independentes e pequenas equipes de jogos já enfrentaram. Um modelo comunitário ajustado com 4B parâmetros oferece outra abordagem: fazer o modelo escrever código Three.js e, depois, exportar o GLB pelo navegador, dividindo a geração e a exportação em duas etapas.
Este não é mais um artigo com uma lista de ferramentas text-to-3D. Os assets exportados pelo Qwen3.5-4B-GLB-3D-Coder já podem ser importados no editor Godot, e o desenvolvedor da comunidade Naoki Kishida chegou a montar uma demo jogável de RPG 3D com assets gerados por ele. Este artigo trata do método de engenharia reutilizável por trás dessa cadeia.
Valor central: depois de ler este artigo, você vai entender por que a camada intermediária de código funciona e aprender a executar, localmente ou na nuvem, o fluxo completo, do comando ao asset no Godot.
Pontos centrais da camada intermediária de código em Three.js
A camada intermediária de código significa que o modelo não gera diretamente o arquivo binário final, mas sim um programa executável, que por sua vez produz o resultado final. Neste caso, o modelo gera um arquivo HTML autônomo, contendo uma cena Three.js e um botão “Export GLB”.
| Ponto | Descrição | Valor para desenvolvedores |
|---|---|---|
| Saída do modelo | Um único arquivo HTML, contendo uma cena Three.js e um botão de exportação | Pode ser lido e modificado diretamente; não é um arquivo caixa-preta |
| Resultado final | Baixar o GLB após clicar no botão no navegador | Pode ser importado no Godot e em outras ferramentas compatíveis com GLB |
| Escopo de treinamento | Cobre 25 áreas de assets de jogos, incluindo personagens, armas, veículos e construções modulares | Uma ferramenta cobre a maior parte das necessidades de placeholder na fase de protótipo |
| Modo de execução | Oferece duas versões quantizadas GGUF: Q4_K_M e Q8_0 | Pode rodar localmente via LM Studio e ferramentas similares |
| Posicionamento de qualidade | Assets de jogos low-poly, não voltados para produção fotorrealista ou de nível cinematográfico | Adequado para protótipos, placeholders e projetos estilizados |
Vale esclarecer que o Qwen3.5-4B-GLB-3D-Coder é uma versão de prévia independente ajustada pelo desenvolvedor CCORE com base no Qwen/Qwen3.5-4B, e não um lançamento oficial da Qwen. Segundo o card do modelo, a maioria dos resultados gerados já pode ser usada na primeira tentativa, especialmente com comandos em inglês, mas alguns assets ainda exigem nova tentativa ou ajuste manual no código.
Fluxo de trabalho da camada intermediária de código Three.js
Todo o fluxo pode ser resumido em seis etapas: inserir a descrição, gerar o HTML, salvar o arquivo, visualizar no navegador, exportar o GLB e importar na engine. As duas primeiras etapas ficam a cargo do modelo; a exportação é feita pelo código executado no navegador, e o modelo não precisa montar diretamente o conteúdo binário do GLB.
Se o asset precisar de movimento, como uma porta que abre, o comando de sistema instrui o modelo a adicionar animação e incluí-la no GLB exportado. Sem uma solicitação explícita, o modelo gera um asset estático por padrão. Por isso, é importante deixar o requisito de animação claro no comando.
5 lições de fluxo de trabalho da camada intermediária de código Three.js
A comparação abaixo é uma avaliação de engenharia baseada neste caso, não um resultado de benchmark. Diferentes abordagens de geração 3D têm seus próprios escopos de aplicação; aqui comparamos apenas as diferenças estruturais entre duas abordagens.
| Dimensão de comparação | Gerar arquivos 3D diretamente | Camada intermediária de código Three.js |
|---|---|---|
| Saída do modelo | Malha ou asset binário | Código de texto legível |
| Tratamento após erro | Normalmente exige regeneração ou entrada em uma ferramenta de modelagem para correção | Permite modificar localmente geometria, materiais e animações |
| Visualização antes da exportação | Depende de ferramentas de visualização dedicadas | Basta abrir o HTML no navegador para visualizar |
| Suporte a animação | Depende do modelo e do pipeline específicos | Pode ser descrito em código e exportado junto com o GLB |
| Escopo em que se destaca | Depende da solução específica | Assets low poly com estrutura clara |
| Principais limitações | O resultado não é fácil de editar em nível granular | Assets com alto nível de detalhe ou fotorrealistas ficam fora do escopo de design |
Lição 1: escolha a camada de representação em que o modelo se destaca. A força dos modelos de código está em produzir texto estruturado, e o Three.js transforma justamente um asset 3D em um problema de programação. Este modelo tem apenas 4B de parâmetros, mas consegue dar conta da tarefa de geração de assets; a chave é que a tarefa foi convertida em um formato que ele consegue processar.
Lição 2: permita que o produto intermediário seja inspecionável. O arquivo HTML é ao mesmo tempo o resultado da geração e a porta de entrada para depuração. Quando um material está no lugar errado ou um loop de animação falha, muitas vezes dá para corrigir manualmente, sem regenerar do zero; isso reduz bastante o custo de uma falha isolada.
Lição 3: deixe a última etapa para ferramentas determinísticas. Os detalhes do formato de arquivo não precisam ficar a cargo de um modelo probabilístico, byte a byte. O próprio ecossistema Three.js tem recursos de exportação como o GLTFExporter; o modelo só precisa escrever a lógica que chama a exportação. Em geral, quanto mais etapas forem delegadas a ferramentas maduras, menor a incerteza no nível do formato.
Lição 4: uma tarefa estreita com convenções fixas é mais prática do que capacidade de generalização. O comando de sistema deste modelo é fixo, e o formato de saída é estritamente limitado a um único arquivo HTML. Ao mesmo tempo, os dados de treinamento de 25 domínios garantem cobertura dos tipos de asset. Com fronteiras de tarefa bem definidas, um modelo pequeno tem espaço suficiente para se destacar.
Lição 5: valide no destino real. Parecer bonito no navegador não significa que o asset seja utilizável; o model card também mostra o resultado após importar no editor Godot. O próximo objetivo do autor também tem a ver com isso: alcançar uma geração confiável em uma única tentativa e automatizar geração, testes e otimização dentro de um framework de agentes.
Essa abordagem não se limita a assets de jogos. Scripts OpenSCAD podem gerar modelos CAD, Python do Blender pode conduzir o fluxo de modelagem, e SVG e Mermaid podem descrever gráficos e diagramas. Sempre que o formato de destino for difícil de gerar diretamente, vale perguntar: existe uma camada de código capaz de produzi-lo de forma estável?
Dica técnica: se quiser comparar o efeito de diferentes modelos ao escrever Three.js, use o mesmo conjunto de comandos para chamar vários modelos via APIYI (apiyi.com) e depois avalie todos com a mesma checklist de aceitação apresentada abaixo.
Primeiros passos com a camada intermediária de código Three.js: implantação local
A seguir, usamos o LM Studio como exemplo, sem precisar escrever nenhum código extra. O LM Studio consegue carregar modelos GGUF diretamente; você pode pesquisar por Qwen3.5-4B-GLB-3D-Coder no navegador de modelos ou baixar o arquivo do Hugging Face e carregá-lo localmente.
Passo 1: escolher a versão quantizada GGUF
A ficha do modelo não divulga a necessidade exata de VRAM, então teste de acordo com o seu hardware. A inferência por CPU também funciona, mas fica bem mais lenta.
| Versão | Características | Cenário recomendado |
|---|---|---|
| Q4_K_M | Arquivo menor, menor consumo de memória, inferência mais rápida, com alguma perda de qualidade | GPU de notebook, dispositivos com configuração limitada, iteração rápida |
| Q8_0 | Arquivo maior, mais próximo da precisão completa | VRAM sobrando, quando você quer aumentar a taxa de sucesso na primeira tentativa com assets complexos |
Atenção às atualizações de versão: as duas versões quantizadas tiveram os pesos substituídos em 2 de novembro de 2026, e o autor afirma que houve uma melhora clara na qualidade visual, mas os nomes dos arquivos não mudaram. Se você baixou antes dessa data, é recomendável apagar e baixar de novo; caso contrário, pode continuar usando a versão antiga.
Passo 2: configurar o comando de sistema e os parâmetros de amostragem
Este modelo foi ajustado com base em um formato de instrução específico, então recomendamos usar exatamente o comando de sistema fornecido na ficha do modelo, sem reescrever:
Create game assets for the Godot editor， which uses GLB files. Create whatever the user requests as a good-quality low-poly asset using only Three.js in one complete standalone HTML file. The HTML must show the asset and include an Export GLB button that downloads a working GLB. If the requested asset needs animation， add it and include the animation in the exported GLB； otherwise make it static.
Cole isso no campo de mensagem de sistema do LM Studio e depois configure os parâmetros de amostragem recomendados pelo autor. Esses valores são um ponto de partida usado nos testes do autor, não uma exigência rígida; você pode ajustá-los depois de fazer funcionar.
| Parâmetro | Valor recomendado | Onde configurar |
|---|---|---|
temperature |
0.8 | Parâmetros de geração do LM Studio |
top_k |
40 | Parâmetros de geração do LM Studio |
top_p |
0.95 | Parâmetros de geração do LM Studio |
min_p |
0.0 | Parâmetros de geração do LM Studio |
Passo 3: gerar e exportar o GLB
O comando do usuário deve ser curto, específico e, de preferência, em inglês. Você pode começar testando Create a blue goblin brute ou Build a jungle siege platform; se precisar de animação, escreva algo como Create a wooden gate with an opening animation. Depois, siga esta ordem:
- Envie o comando e aguarde o modelo gerar o HTML completo.
- Salve o conteúdo gerado como um arquivo
.html. - Abra o arquivo no navegador e confirme que o asset é renderizado corretamente.
- Clique no botão “Export GLB” e baixe o arquivo
.glb. - Importe o GLB no Godot ou em outra ferramenta compatível com o formato.
Se a página ficar em branco, primeiro abra as ferramentas de desenvolvedor do navegador e verifique os erros no console. Alguns scripts podem sofrer restrições de arquivo local do navegador quando abertos com clique duplo; nesse caso, execute python -m http.server no diretório do arquivo e acesse pelo endereço local.
Passo 4: validar o asset com uma checklist
Não se limite a olhar a prévia no navegador. Recomenda-se verificar os itens abaixo em cada asset:
- Estrutura: as partes estão completas? Há desalinhamentos ou interseções óbvios?
- Materiais: as cores e os materiais continuam iguais aos da prévia depois da importação na engine?
- Animação: a animação foi realmente gravada no GLB e consegue ser reproduzida dentro da engine?
- Escala e origem: a proporção e o pivô atendem às necessidades da cena? Essa parte pode exigir ajuste manual.
- Facilidade de correção: para problemas pequenos, prefira alterar o código; para problemas estruturais, gere novamente.
Solução de acesso em nuvem para a camada intermediária de código Three.js
Uma das vantagens da camada intermediária de código é que ela não fica presa a um modelo específico. Desde que o modelo consiga escrever Three.js executável, ele pode ser integrado ao mesmo fluxo. De acordo com informações públicas, o Qwen3.5-4B-GLB-3D-Coder é distribuído atualmente no formato GGUF, principalmente para inferência local; se o seu dispositivo não for adequado para executá-lo, ou se você quiser comparar o desempenho de modelos de codificação generalistas, pode usar a API em nuvem.
A APIYI oferece chamadas de API para diversos modelos, compatíveis com os formatos de interface da OpenAI e da Anthropic. Clientes já existentes normalmente só precisam ajustar o endereço da API, a chave e o nome do modelo. Vale observar que a disponibilidade de chamadas em nuvem para o modelo ajustado mencionado acima deve ser confirmada na própria lista de modelos. Para detalhes de configuração, consulte a documentação da APIYI: docs.apiyi.com.
| Solução | Características principais | Cenários de uso | Critério de cobrança | Plataformas disponíveis |
|---|---|---|---|---|
| Modelo local ajustado | Ajustado para ativos GLB, pode ser usado offline após o download | Geração em lote de ativos provisórios, necessidade de execução offline | Sem taxa por chamada, requer hardware próprio | Ferramentas de execução GGUF, como o LM Studio |
| Modelo de codificação generalista na nuvem | Dispensa capacidade computacional local, facilita a troca e a comparação | Dispositivos com limitações, necessidade de testar comandos complexos | Conforme a página de preços da APIYI | APIYI (apiyi.com) e canais oficiais de cada modelo |
| Misto: local e nuvem | Executa grandes volumes localmente e envia ativos difíceis para a nuvem | Equipes que desejam equilibrar custo e taxa de sucesso | A parte na nuvem segue a página de preços da APIYI | Ferramentas locais combinadas com a plataforma de API |
Etapas para chamar o modelo de geração de Three.js via API
- No console da APIYI, crie uma chave API e confirme na documentação o endereço atual da API; não copie o endereço de tutoriais de terceiros.
- De acordo com o cliente existente, escolha o formato de interface da OpenAI ou da Anthropic e preencha
base_urle a chave API. - Na lista de modelos, selecione o modelo que deseja testar e insira o nome dele no campo
model. - Coloque o comando de sistema apresentado anteriormente na mensagem system. Como o modelo generalista não foi ajustado para esta tarefa, você pode adicionar restrições como “gere apenas o HTML completo”.
- Salve a resposta em um arquivo
.html; as etapas seguintes de pré-visualização, exportação e validação são as mesmas da solução local.
O serviço local do LM Studio também oferece uma interface compatível com OpenAI. Assim, você pode usar o mesmo cliente para alternar entre local e nuvem, bastando mudar o endereço da API e o nome do modelo. Com isso, as etapas de pré-visualização, exportação e validação que vêm depois da camada intermediária de código não precisam ser alteradas.
Observação sobre cobrança: o preço unitário dos modelos, os critérios de cobrança de entrada e saída e os preços de cache podem mudar. Este artigo não traz números específicos; em todos os casos, valem os dados reais da página de preços da APIYI: https://docs.apiyi.com/models.
Perguntas frequentes (FAQ)
Q1: O que é o fluxo de trabalho com camada intermediária de código Three.js?
Significa pedir ao modelo que primeiro escreva um programa Three.js, que então renderiza e exporta um GLB, em vez de deixar o modelo gerar o arquivo 3D diretamente. Assim, é possível visualizar e modificar o resultado antes da exportação.
Q2: O Qwen3.5-4B-GLB-3D-Coder consegue gerar GLB diretamente?
Não. Ele gera um arquivo HTML independente, que precisa ser aberto no navegador e ter o botão “Export GLB” clicado para que o arquivo GLB seja obtido.
Q3: O GLB exportado só serve para o Godot?
Não. O prompt do sistema tem como alvo o fluxo de trabalho do Godot, mas o GLB é um formato universal, que também pode ser importado por Unity, Blender e visualizadores 3D para web. No entanto, o resultado após a importação ainda precisa ser verificado separadamente em cada ferramenta.
Q4: Quais cenários de aplicação combinam mais com este modelo?
Ele é mais indicado para protótipos de jogos em estilo low poly e assets de placeholder, como NPCs, armas, veículos, construções modulares e armadilhas. Se você precisa de assets finais altamente personalizados, ainda será necessário fazer ajustes manuais após a importação.
Q5: Sem uma GPU adequada, como posso experimentar esse fluxo via API?
Você pode chamar os modelos de código da lista de modelos através do APIYI apiyi.com e configurar a interface no formato OpenAI ou Anthropic conforme a documentação. Depois que o modelo gera o HTML, a visualização e a exportação subsequentes são feitas localmente no navegador.
Q6: Como são calculados os custos das chamadas na nuvem?
O preço unitário e os critérios de cobrança variam entre os modelos, então consulte diretamente a página de preços do APIYI: https://docs.apiyi.com/models. Recomenda-se fazer um teste inicial com poucos prompts e depois estimar o custo com base no uso real.
Q7: O arquivo de projeção visual é obrigatório?
Não é obrigatório. O arquivo opcional de projeção visual BF16 tem cerca de 644 MiB e serve para inserir imagens de referência em ambientes de execução que suportam o Qwen3.5 multimodal em GGUF. Se você usar apenas prompts de texto, pode deixar de baixá-lo.
Q8: Quais são as limitações atuais desta solução?
Atualmente é uma versão de pré-visualização; o conjunto de treinamento tem ênfase em prompts simples, a capacidade de generalização para demandas complexas ou incomuns é limitada, e ela não é voltada para assets fotorrealistas. O autor planeja publicar o conjunto de dados e os pesos Safetensors, além de treinar uma versão maior com cerca de 100 mil amostras e comprimento de contexto entre 8K e 128K tokens, mas esse conteúdo ainda não foi publicado.
Pontos-chave da camada intermediária de código Three.js
- Ideia central: deixar o modelo escrever Three.js executável e, em seguida, exportar o GLB por meio de um programa.
- Vantagem principal: o artefato intermediário pode ser pré-visualizado, lido e modificado localmente, reduzindo o custo do fracasso.
- Primeiros passos locais: carregar o GGUF no LM Studio, com um comando de sistema fixo e os parâmetros de amostragem recomendados.
- Aviso de versão: pesos baixados antes de 2 de novembro devem ser excluídos e baixados novamente.
- Limites de aplicação: adequado para protótipos low-poly e assets placeholder, não para produções realistas ou de nível cinematográfico.
- Caminho na nuvem: é possível acessar modelos nos formatos OpenAI ou Anthropic via APIYI e comparar os resultados.
- Extensão do método: cenários como Blender Python e OpenSCAD também podem se beneficiar desse design de camada intermediária.
Conclusão
A inspiração do Qwen3.5-4B-GLB-3D-Coder não está apenas no fato de um modelo pequeno conseguir gerar assets de jogo, mas em como ele redistribui as responsabilidades entre o modelo e as ferramentas:
- O modelo é responsável pela expressão: transformar descrições em linguagem natural em código Three.js com estrutura clara.
- A ferramenta é responsável pela materialização: o navegador e a lógica de exportação geram o arquivo GLB padrão.
- A validação determina a usabilidade: só quando o asset é importado na engine de destino e passa nas verificações é que o trabalho está realmente concluído.
A recomendação é começar com um item estático simples para validar todo o fluxo e, depois, testar animações e assets mais complexos aos poucos. Se quiser comparar vários modelos na nuvem, é possível fazer chamadas unificadas via APIYI; os detalhes de integração estão em docs.apiyi.com, e os preços devem ser consultados com base nos dados reais em https://docs.apiyi.com/models.
📚 Referências
- Apresentação do modelo Qwen3.5-4B-GLB-3D-Coder: posicionamento do modelo, 25 domínios de assets e roadmap futuro
- Link:
mindstudio.ai/blog/qwen3-5-4b-glb-3d-coder-model -
Descrição: ideal para entender a visão geral do projeto e casos da comunidade
-
Guia de execução local do Qwen3.5-4B-GLB-3D-Coder: mecanismo de geração, versões quantizadas e análise de aplicabilidade
- Link:
mindstudio.ai/blog/qwen3-5-4b-glb-3d-coder-local -
Descrição: útil para avaliar se o modelo atende às necessidades do seu projeto
-
Guia de configuração do LM Studio: comando de sistema, parâmetros de amostragem e passos para exportar GLB
- Link:
mindstudio.ai/blog/run-qwen3-5-glb-3d-coder-locally -
Descrição: ideal para concluir a implantação local passo a passo
-
Documentação e página de preços do APIYI: instruções de integração da API e dados de preços dos modelos
- Link:
docs.apiyi.comedocs.apiyi.com/models - Descrição: as informações de configuração da interface e de cobrança seguem o conteúdo mais recente disponível aqui
Autor: Equipe técnica do APIYI
Contato técnico: se tiver dúvidas durante a integração, fale conosco pelo site oficial do APIYI, apiyi.com. Mais materiais estão disponíveis no centro de documentação docs.apiyi.com
