Pesquisa atualizada em 14 de julho de 2026

Este guia foi feito para quem quer criar jogos pequenos, engraçados, experimentais ou deliberadamente bobos sem transformar o hobby em um curso de engenharia aeroespacial. A prioridade aqui é: chegar rapidamente a algo jogável, aprender os fundamentos de verdade e só depois aumentar a complexidade.

Resumo direto

Para começar sem perder semanas escolhendo ferramenta:

1. GDevelop — melhor porta de entrada geral para criar jogos 2D sem depender de programação.
2. Godot — melhor ferramenta para aprender desenvolvimento de jogos de forma séria sem cair no peso de Unity ou Unreal.
3. Phaser — melhor escolha para quem já programa e quer publicar jogos diretamente na web.
4. Bitsy — melhor para minijogos narrativos estranhos, pequenos mundos e experimentos rápidos.
5. Twine — melhor para ficção interativa, histórias ramificadas e jogos baseados em escolhas.
6. GB Studio — melhor para jogos retrô no estilo Game Boy, usando lógica visual.
7. Ren'Py — melhor para visual novels e jogos fortemente baseados em texto, personagens e diálogos.
8. PICO-8 — melhor para aprender programação de jogos dentro de limites criativos deliberadamente pequenos.
9. Construct 3 — excelente e extremamente amigável, mas seu modelo comercial pode pesar mais do que GDevelop ou Godot.
10. GameMaker — bom meio-termo entre ferramenta visual e programação, especialmente para jogos 2D.

Minha recomendação específica

Como você já é programador, mas quer aprender fazendo coisas simples:

• Faça os dois primeiros jogos no GDevelop.
• Depois passe para Godot como ferramenta principal.
• Use Phaser quando o objetivo for colocar um jogo em um site sem downloads.
• Use Bitsy, Twine e GB Studio para projetos de fim de semana, experiências narrativas e ideias deliberadamente esquisitas.
• Não comece por Unity ou Unreal. Elas não são ruins; são apenas grandes demais para o problema que você quer resolver.

1. O que você realmente precisa aprender

Antes das ferramentas, há cinco conceitos que aparecem em praticamente qualquer jogo:

1. Estado — menu, jogando, pausado, vitória, derrota.
2. Entrada — teclado, mouse, controle ou toque.
3. Atualização — o que muda a cada instante.
4. Colisão e regras — o que acontece quando coisas se encontram.
5. Feedback — som, animação, partículas, texto, pontos e resposta visual.

Um iniciante costuma achar que precisa primeiro aprender gráficos 3D, inteligência artificial, física avançada e arquitetura de software. Isso é desperdício. Um primeiro jogo precisa somente de:

• uma ação principal;
• uma condição de vitória ou pontuação;
• uma condição de falha;
• reinício;
• algum feedback audiovisual.

Exemplo: clicar em um pato que foge do cursor durante 30 segundos já é um jogo completo.

2. Ranking geral das ferramentas

3. As melhores opções sem código

3.1 GDevelop

Site: https://gdevelop.io/pt-br
Documentação: https://wiki.gdevelop.io/

GDevelop é provavelmente a melhor resposta geral para “quero fazer um joguinho agora”. É uma engine open source com sistema de eventos visuais, comportamentos prontos, física, partículas, caminhos, câmeras, interface e exportação para várias plataformas.

Pontos fortes

• lógica por eventos, sem exigir código;
• editor visual relativamente simples;
• templates e exemplos prontos;
• exportação para web, desktop e mobile;
• suporte a jogos 2D, recursos 3D e multiplayer;
• JavaScript disponível quando a lógica visual deixar de ser suficiente;
• documentação e interface em português;
• assistência por IA integrada, sem tornar a IA obrigatória.

Limitações

• projetos grandes podem virar uma floresta de eventos;
• alguns serviços de publicação e nuvem dependem de planos;
• ensina lógica de jogos, mas não necessariamente boas práticas de programação;
• a interface ainda possui mais elementos do que Bitsy ou Scratch.

Jogos ideais para começar

• Flappy Bird simplificado;
• clicker;
• jogo de desviar;
• plataforma de uma tela;
• top-down shooter;
• Pong;
• jogo de memória;
• endless runner.

Veredito

A melhor ferramenta para terminar o primeiro jogo.

3.2 Construct 3

Site: https://www.construct.net/en
Teste no navegador: https://www.construct.net/en/make-games/free-trial
Guia inicial: https://www.construct.net/en/tutorials/beginners-guide-construct-1

Construct 3 roda no navegador e possui um sistema de eventos excelente. É uma das ferramentas mais polidas para criação visual de jogos 2D.

Pontos fortes

• não exige instalação para testar;
• sistema de eventos extremamente legível;
• grande quantidade de exemplos e templates;
• JavaScript pode ser adicionado gradualmente;
• publicação web muito natural;
• excelente documentação;
• bom editor de comportamentos, layouts e animações.

Limitações

• o plano gratuito é limitado;
• assinatura ou licença pode ser necessária conforme o projeto cresce;
• menor liberdade do que Godot em projetos muito personalizados;
• você pode ficar dependente da plataforma.

Veredito

Excelente, talvez até mais polido que GDevelop em alguns pontos, mas GDevelop costuma ser uma escolha inicial financeiramente mais tranquila.

3.3 Scratch

Site: https://scratch.mit.edu/
Sobre: https://scratch.mit.edu/about/

Scratch é frequentemente tratado como ferramenta infantil, mas isso não o torna inútil. Ele ensina eventos, variáveis, condições, loops, mensagens e clonagem de objetos sem ruído técnico.

Pontos fortes

• começa em segundos;
• comunidade gigantesca;
• blocos visuais claros;
• ideal para compreender lógica;
• compartilhamento instantâneo;
• praticamente impossível quebrar o ambiente.

Limitações

• não é ideal para distribuir jogos comerciais;
• limitações de desempenho e estrutura;
• projetos grandes ficam confusos;
• estética e comunidade fortemente associadas à educação infantil.

Veredito

Use durante um ou dois dias caso nunca tenha programado lógica interativa. Como você já programa, provavelmente pode pular direto para GDevelop.

3.4 Buildbox

Site: https://www.buildbox.com/

Buildbox oferece criação por arrastar e soltar, templates e recursos de IA. É direcionado a protótipos rápidos e jogos casuais.

Pontos fortes

• muitos templates;
• prototipagem rápida;
• pouca programação;
• adequado para jogos mobile casuais;
• ferramentas visuais e recursos pré-configurados.

Limitações

• modelo comercial;
• menor liberdade técnica;
• projetos tendem a parecer feitos com templates se não houver customização;
• aprender Buildbox não transfere tão bem para programação de jogos quanto aprender Godot.

Veredito

Funciona, mas não é minha primeira recomendação. GDevelop e Construct entregam caminhos mais interessantes para aprender.

3.5 Rosebud AI

Site: https://rosebud.ai/

Rosebud transforma descrições em protótipos jogáveis. É útil para testar uma ideia, observar como uma mecânica pode funcionar e gerar um primeiro rascunho.

Pontos fortes

• resultado inicial muito rápido;
• não exige instalação;
• útil para brainstorming;
• permite experimentar gêneros diferentes;
• reduz a barreira de entrada.

Limitações reais

• gerar não significa entender;
• código e estrutura podem ser difíceis de manter;
• a qualidade cai quando o projeto cresce;
• a IA tende a produzir variações de padrões conhecidos;
• depurar algo que você não compreende é pior do que escrever algo pequeno;
• não substitui aprender estado, eventos, colisões e feedback.

Veredito

Use como máquina de protótipos, não como sua formação principal. IA é atalho para gerar; não é atalho garantido para manter.

4. Ferramentas para jogos narrativos

4.1 Bitsy

Site: https://make.bitsy.org/

Bitsy é um pequeno editor para criar pequenos mundos em que o jogador anda, conversa, encontra objetos e atravessa salas.

Por que ele é especial

Ele é deliberadamente limitado. Isso é uma vantagem. Em vez de escolher entre 400 sistemas, você trabalha com:

• salas pequenas;
• personagens;
• diálogos;
• itens;
• saídas;
• finais;
• uma paleta reduzida.

Ideias perfeitas para Bitsy

• uma casa assombrada de cinco cômodos;
• um museu absurdo;
• um diário caminhável;
• uma conversa com um fantasma;
• um jogo-poema;
• uma visita a um planeta minúsculo;
• autobiografia interativa;
• passeio por uma biblioteca impossível.

Veredito

A ferramenta mais fácil desta lista para realmente terminar algo autoral em uma noite.

4.2 Twine

Site: https://twinery.org/
Guia: https://twinery.org/2guide
Cookbook: https://twinery.org/cookbook/

Twine cria histórias não lineares que podem ser exportadas como HTML. Você começa conectando passagens de texto e depois pode adicionar variáveis, condições, imagens, CSS e JavaScript.

Pontos fortes

• não exige programação para uma história simples;
• exporta um único HTML;
• ótimo para publicar em qualquer site;
• permite avançar gradualmente;
• excelente para terror, mistério, escolhas e experimentação literária;
• combina muito bem com sua experiência web.

Limitações

• não é uma engine para ação em tempo real;
• interfaces mais elaboradas exigem CSS e JavaScript;
• histórias com centenas de ramificações exigem planejamento.

Primeiro projeto ideal

Uma história com:

• 10 passagens;
• 3 escolhas importantes;
• 2 variáveis;
• 3 finais;
• uma imagem;
• um efeito sonoro.

Veredito

Uma das melhores ferramentas para entender design de escolhas e consequências.

4.3 Ren'Py

Site: https://www.renpy.org/
Quickstart: https://www.renpy.org/doc/html/quickstart.html

Ren'Py é uma engine gratuita e open source para visual novels e simulações narrativas. Sua linguagem de script é simples, e Python pode ser usado para sistemas mais complexos.

Pontos fortes

• diálogos e personagens são fáceis de definir;
• menus, escolhas, save/load e histórico já estão resolvidos;
• suporta imagens, transições, música e voz;
• pode crescer para dating sims, simuladores e jogos de gerenciamento;
• gratuito para projetos comerciais e não comerciais.

Limitações

• não é a ferramenta mais indicada para plataforma ou ação;
• personalizações profundas exigem aprender a linguagem de tela e Python;
• exige organização de roteiro e assets.

Veredito

Para visual novel, não complique: use Ren'Py.

4.4 RPG Maker

Site: https://www.rpgmakerweb.com/
Teste: https://www.rpgmakerweb.com/downloads

RPG Maker oferece mapas, banco de dados, personagens, batalhas, inventário e eventos prontos para RPGs no estilo 16-bit.

Pontos fortes

• permite criar um RPG rapidamente;
• grande ecossistema de plugins e assets;
• editor de mapas acessível;
• eventos visuais;
• sistemas comuns já vêm prontos.

Limitações

• pago;
• projetos genéricos ficam com aparência de RPG Maker;
• sair do molde exige plugins e JavaScript;
• iniciantes frequentemente começam um RPG de 40 horas e nunca terminam.

Regra obrigatória

Seu primeiro RPG deve durar dez minutos, não quarenta horas.

5. Ferramentas retrô e “fantasy consoles”

5.1 GB Studio

Site: https://www.gbstudio.dev/
Documentação: https://www.gbstudio.dev/docs/
Primeiros passos: https://www.gbstudio.dev/docs/getting-started/

GB Studio é um criador de jogos com arrastar e soltar e scripting visual voltado ao estilo Game Boy. Ele pode gerar ROMs reais e versões web.

Pontos fortes

• visual scripting;
• exemplos prontos;
• estética coerente por padrão;
• limitações ajudam a controlar o escopo;
• cria aventuras top-down, plataformas, shooters e outros formatos;
• possui editor de música;
• exporta para navegador e ROM.

Limitações

• restrições inspiradas no hardware;
• assets precisam respeitar formatos e paletas;
• sistemas muito complexos exigem extensões ou conhecimento técnico.

Veredito

Excelente para criar um jogo retrô pequeno sem lutar contra uma engine genérica.

5.2 PICO-8

Site: https://www.lexaloffle.com/pico-8.php
Manual: https://www.lexaloffle.com/dl/docs/pico-8_manual.html
Recursos: https://www.lexaloffle.com/pico-8.php?page=resources

PICO-8 é um “console de fantasia”: uma máquina que nunca existiu, com resolução, paleta, memória e tamanho de código limitados.

Inclui:

• editor de código;
• editor de sprites;
• editor de mapas;
• editor de efeitos;
• editor de música;
• navegador de cartuchos;
• linguagem Lua.

Pontos fortes

• tudo está integrado;
• restrições combatem o perfeccionismo;
• comunidade criativa;
• muitos jogos pequenos cujo código pode ser estudado;
• ótima forma de aprender loops, tabelas, entidades e colisões.

Limitações

• pago;
• limites podem frustrar quem quer um projeto grande;
• interface retrô não agrada todo mundo;
• não é uma ferramenta de arrastar e soltar.

Veredito

Uma das melhores maneiras de aprender programação de jogos pequenos de verdade.

5.3 microStudio

Site: https://microstudio.dev/pt/

microStudio funciona no navegador e combina código, sprites, mapas, documentação, armazenamento e publicação.

Pontos fortes

• gratuito;
• não exige instalação;
• editor de sprite integrado;
• editor de mapas integrado;
• tutorial interativo;
• suporta diferentes linguagens;
• ótimo para protótipos e game jams.

Limitações

• ecossistema menor;
• menos tutoriais que Godot ou Phaser;
• não é tão conhecido no mercado;
• interface online pode não agradar em projetos maiores.

Veredito

Uma joia pouco comentada. É especialmente boa para aprender programando sem montar um ambiente inteiro.

6. Engines e frameworks com programação

6.1 Godot

Site: https://godotengine.org/
Documentação: https://docs.godotengine.org/en/stable/
Curso passo a passo: https://docs.godotengine.org/en/stable/getting_started/step_by_step/index.html
Trilha GDQuest: https://www.gdquest.com/tutorial/godot/learning-paths/beginner/

Godot é uma engine gratuita e open source para 2D e 3D. Usa uma arquitetura baseada em cenas e nós. Sua principal linguagem, GDScript, lembra Python.

Pontos fortes

• gratuita, open source e sem royalties;
• editor relativamente leve;
• excelente fluxo 2D;
• GDScript simples;
• cenas e nós incentivam composição;
• exporta para desktop, web e mobile;
• comunidade e documentação grandes;
• adequada tanto para jogo pequeno quanto para algo bem maior.

Dificuldades iniciais

• entender nós, cenas e instâncias;
• compreender sinais;
• distinguir _process de _physics_process;
• organizar cenas sem criar dependências confusas;
• aprender coordenadas e vetores.

Primeiro projeto recomendado

Não faça plataforma primeiro. Faça:

1. arena de uma tela;
2. personagem que se move;
3. inimigos que perseguem;
4. tiro;
5. pontos;
6. cronômetro de 60 segundos;
7. reinício.

Isso ensina mais fundamentos com menos problemas de física de plataforma.

Veredito

Melhor escolha de longo prazo para você.

6.2 Phaser

Site: https://phaser.io/
Documentação: https://docs.phaser.io/
Tutoriais: https://phaser.io/learn
Tutorial MDN: https://developer.mozilla.org/en-US/docs/Games/Tutorials

Phaser é um framework open source para jogos HTML5, com renderização WebGL e Canvas. Usa JavaScript ou TypeScript.

Pontos fortes

• jogos rodam no navegador;
• integração natural com sites;
• JavaScript/TypeScript;
• excelente para hospedar você mesmo;
• física, sprites, tilemaps, câmeras, áudio e input;
• muitos exemplos;
• ecossistema maduro.

Limitações

• é framework, não uma engine visual completa;
• você precisa estruturar arquivos e código;
• criar UI, pipeline e ferramentas exige decisões;
• exportar para lojas nativas costuma envolver ferramentas adicionais.

Ideal para você quando

• quiser um jogo incorporado a um site;
• quiser publicar em um subdomínio;
• quiser criar widgets interativos;
• quiser integrar placar, API, banco de dados ou login;
• quiser distribuir como HTML5 no itch.io.

Atenção ao Kaboom.js

Kaboom.js aparece em muitos tutoriais antigos, mas o próprio site informa que ele não é mais mantido. Não comece um projeto novo importante nele. Phaser é a escolha mais segura.

Veredito

Melhor framework para o seu lado programador e web.

6.3 GameMaker

Site: https://gamemaker.io/pt-BR
Tutoriais: https://gamemaker.io/en/tutorials

GameMaker é especializado em 2D e oferece tanto lógica visual quanto GML, sua linguagem própria.

Pontos fortes

• bom editor 2D;
• curva inicial amigável;
• muitos tutoriais completos;
• permite começar visualmente e migrar para código;
• adequado para arcades, plataforma, RPG e ação 2D.

Limitações

• linguagem e ecossistema próprios;
• licenciamento varia conforme publicação e plataforma;
• menos aberto que Godot;
• projetos podem se tornar dependentes da ferramenta.

Veredito

Muito bom, mas para alguém que valoriza software livre e controle, Godot tende a ser uma escolha mais coerente.

6.4 Defold

Site: https://defold.com/
Tutoriais: https://defold.com/tutorials/
Cursos: https://defold.com/courses/

Defold é uma engine gratuita, leve e orientada a Lua, conhecida por builds pequenos e bom suporte multiplataforma.

Pontos fortes

• leve;
• Lua;
• boa documentação;
• tutoriais integrados;
• builds compactos;
• adequada para 2D e mobile;
• desenvolvimento ativo.

Limitações

• comunidade menor que Godot;
• arquitetura não é tão imediata para novatos;
• menos conteúdo em português;
• editor e fluxo podem parecer mais técnicos.

Veredito

Boa segunda ou terceira engine. Não é a rota mais curta para o primeiro jogo.

6.5 LÖVE / Love2D

Site: https://love2d.org/
Wiki: https://www.love2d.org/wiki/Main_Page
Primeiros passos: https://www.love2d.org/wiki/Getting_Started

LÖVE é um framework gratuito para jogos 2D em Lua.

Pontos fortes

• API pequena;
• muito leve;
• ótimo para compreender game loop;
• liberdade total;
• fácil de versionar;
• excelente para jogos pequenos e game jams.

Limitações

• não possui editor visual completo;
• você constrói mais sistemas manualmente;
• gerenciamento de cenas e entidades depende de você;
• distribuição exige aprender o empacotamento.

Veredito

Ótimo para aprender programação de jogos, mas menos rápido que GDevelop ou Godot.

6.6 Pygame

Site: https://www.pygame.org/
Documentação: https://www.pygame.org/docs/
Guia para iniciantes: https://www.pygame.org/docs/tut/newbieguide.html

Pygame é uma biblioteca Python que fornece janela, input, áudio, superfícies, sprites e outras bases para jogos 2D.

Pontos fortes

• usa Python;
• mostra claramente como funciona um game loop;
• ótimo para aprendizado;
• muitos exemplos;
• liberdade para construir sua arquitetura.

Limitações

• não é uma engine completa;
• você fará manualmente várias coisas que Godot já resolve;
• publicação web não é seu caminho mais natural;
• performance e empacotamento podem exigir atenção;
• a liberdade inicial também permite criar código bagunçado rapidamente.

Veredito

Use se o objetivo for aprender programação, não se o único objetivo for terminar um jogo o mais rápido possível.

6.7 Unity

Site: https://unity.com/
Manual para iniciantes: https://docs.unity3d.com/6000.3/Documentation/Manual/first-time-user.html

Unity possui um enorme ecossistema, 2D, 3D, C#, Asset Store e muitas plataformas de exportação.

Por que não recomendo começar aqui

• instalação e gerenciamento de versões;
• editor pesado;
• enorme quantidade de conceitos;
• ecossistema que incentiva comprar assets e plugins;
• excesso de tutoriais desatualizados;
• o iniciante pode gastar mais tempo configurando do que criando.

Quando usar

• necessidade específica de C#;
• projeto 3D;
• curso ou equipe que já usa Unity;
• asset ou SDK disponível apenas para Unity;
• objetivo profissional claramente ligado ao ecossistema.

6.8 Unreal Engine

Unreal é extraordinária para 3D avançado, renderização e projetos de alta fidelidade. Blueprints permite lógica visual, mas a engine continua complexa.

Não é adequada para

• Pong;
• clickers;
• jogos web pequenos;
• primeiro jogo 2D;
• quem quer aprender em sessões curtas.

Use somente quando

O projeto realmente precisar de seu pipeline 3D, renderização, ferramentas cinematográficas ou ecossistema.

7. Ferramentas para pixel art e animação

7.1 Aseprite

Site: https://www.aseprite.org/
Documentação: https://www.aseprite.org/docs/

Editor especializado em pixel art e animações. Trabalha com frames, layers, onion skin, tags de animação, palettes e sprite sheets.

Melhor para: quem quer produzir pixel art com frequência.
Custo: comercial, com código-fonte disponível sob licença própria.
Veredito: vale comprar quando você perceber que pixel art virou parte do hobby.

7.2 LibreSprite

Site: https://libresprite.github.io/

Alternativa gratuita e open source para criar e animar sprites.

Melhor para: começar sem gastar.
Limitação: experiência e ritmo de desenvolvimento podem ser menos polidos que Aseprite.

7.3 Pixelorama

Site: https://pixelorama.org/

Editor open source de pixel art com animação, onion skin, layers e ferramentas modernas.

Melhor para: alternativa gratuita mais ativa e rica.
Veredito: minha primeira indicação gratuita para pixel art.

7.4 Piskel

Site: https://www.piskelapp.com/

Editor simples de sprites no navegador.

Melhor para: desenhar rapidamente um personagem, item ou animação curta.
Limitação: não é ideal para projetos artísticos maiores.

7.5 Krita

Site: https://krita.org/

Editor open source de pintura digital e animação.

Melhor para: ilustrações, fundos, retratos, concept art e interfaces.
Não é: uma ferramenta exclusivamente de pixel art.

8. Editores de mapas e fases

8.1 Tiled

Site: https://www.mapeditor.org/
Documentação: https://doc.mapeditor.org/

Tiled é um editor flexível de mapas baseado em tiles. Suporta mapas ortogonais, isométricos e hexagonais, objetos, propriedades e vários formatos.

Use quando

• seu jogo possui mapas grandes;
• você usa Phaser, LÖVE ou outra framework;
• precisa separar design de fases do código;
• quer editar colisões e entidades visualmente.

8.2 LDtk

Site: https://ldtk.io/

LDtk é um editor 2D open source criado com forte foco em usabilidade. Trabalha com níveis, entidades, grids, layers, regras automáticas e exportação estruturada.

Use quando

• deseja uma experiência mais moderna que Tiled;
• quer auto-tiling;
• precisa definir tipos de entidades;
• sua engine ou framework possui importador de LDtk.

Escolha simples

• Tiled: máximo de compatibilidade.
• LDtk: fluxo mais opinativo e moderno.

9. Sons e música sem virar músico profissional

9.1 ChipTone

Site: https://sfbgames.itch.io/chiptone

Gerador visual de efeitos sonoros. Sons criados nele podem ser usados para qualquer finalidade sob CC0, conforme a página oficial.

Faça com ele: pulos, tiros, moedas, dano, explosões, cliques e power-ups.

9.2 jsfxr

Site: https://sfxr.me/

Gerador online de efeitos sonoros 8-bit. Também pode funcionar como biblioteca JavaScript.

Melhor para: produzir placeholders em segundos.

9.3 Bfxr

Site: https://www.bfxr.net/

Ferramenta clássica para gerar e modificar efeitos sonoros de jogos.

Melhor para: game jams e efeitos retrô.

9.4 Bosca Ceoil Blue

Projeto: https://github.com/YuriSizov/boscaceoil-blue
Documentação: https://humnom.net/apps/boscaceoil/docs/

Sequenciador gratuito e amigável para criar músicas por padrões.

Melhor para: quem não entende teoria musical e precisa de loops simples.

9.5 BeepBox

Site: https://www.beepbox.co/

Sequenciador online para criar chiptunes e músicas em padrões.

Melhor para: loops curtos, compartilhamento por URL e experimentação rápida.

9.6 Audacity

Site: https://www.audacityteam.org/

Editor open source para cortar, normalizar, limpar e converter áudio.

Use para: preparar efeitos, editar vozes, ajustar volume e exportar WAV/OGG.

10. Assets gratuitos e recursos visuais

10.1 Kenney

Site: https://kenney.nl/assets

Kenney oferece muitos pacotes 2D, 3D, UI, áudio, texturas e starter kits. É uma das melhores fontes para protótipos porque os packs costumam ser visualmente consistentes.

Regra prática

No primeiro jogo, use um único pack. Misturar cinco estilos diferentes produz um Frankenstein visual.

10.2 OpenGameArt

Site: https://opengameart.org/

Repositório comunitário de arte, música e efeitos sob diferentes licenças livres.

Atenção

“Gratuito” não significa “sem obrigação”. Confira individualmente:

• CC0;
• domínio público;
• CC-BY;
• CC-BY-SA;
• outras licenças.

Mantenha um arquivo CREDITS.md desde o primeiro dia.

10.3 itch.io Assets

Site: https://itch.io/game-assets

Grande variedade de sprites, tilesets, interfaces, fontes, música e efeitos gratuitos ou pagos.

Como procurar

Use filtros como:

• free;
• pixel art;
• 2D;
• GUI;
• tileset;
• sound effects;
• CC0;
• fantasy;
• sci-fi;
• top-down.

10.4 Game-icons.net

Site: https://game-icons.net/

Milhares de ícones em SVG e PNG. A maioria é distribuída sob CC BY 3.0 e exige crédito ao autor.

Ótimo para: inventário, habilidades, cartas, botões e indicadores.

10.5 Freesound

Site: https://freesound.org/
FAQ de licenças: https://freesound.org/help/faq/

Biblioteca enorme de sons enviados pela comunidade.

Cuidado

Cada som pode ter uma licença diferente. Filtre por CC0 quando quiser minimizar obrigações, ou registre corretamente os créditos.

11. Onde publicar

11.1 itch.io

Guia inicial: https://itch.io/docs/creators/getting-started
Jogos HTML5: https://itch.io/docs/creators/html5
Game jams: https://itch.io/jams

itch.io é a melhor plataforma para publicar primeiros jogos.

Vantagens

• conta gratuita;
• hospeda arquivos;
• executa jogos HTML5 no navegador;
• permite downloads;
• páginas personalizáveis;
• analytics;
• preço zero, fixo ou “pague quanto quiser”;
• game jams;
• comunidade indie.

Publicação HTML5

Normalmente você exporta um ZIP contendo index.html e os demais arquivos. O itch.io hospeda e incorpora o jogo na página.

11.2 Seu próprio site

Para projetos Phaser, Twine, Bitsy, GDevelop web ou Godot web, você pode hospedar os arquivos em:

• Nginx;
• GitHub Pages;
• Cloudflare Pages;
• Netlify;
• Vercel;
• seu próprio VPS.

Ideia para seu ecossistema

Criar um subdomínio como:

• games.pablomurad.com;
• play.runv.club;
• arcade.murad.world;
• lab.runv.sh.

Você poderia manter uma pequena galeria de jogos experimentais, cada um com página própria, changelog e código no Forgejo.

12. Trilhas recomendadas

Trilha A — Quero resultado em uma tarde

Stack:

• GDevelop;
• assets Kenney;
• ChipTone;
• publicação no itch.io.

Projeto: desviar de objetos durante 60 segundos.

O que aprender:

• movimentação;
• spawn;
• colisão;
• variável de pontuação;
• timer;
• tela de derrota;
• reinício.

Trilha B — Quero aprender desenvolvimento de jogos de verdade

Stack:

• Godot;
• GDScript;
• Pixelorama ou Aseprite;
• ChipTone;
• Kenney;
• itch.io.

Sequência:

1. Pong;
2. arena shooter;
3. puzzle de uma tela;
4. plataforma curto;
5. jogo top-down com três salas.

Trilha C — Quero fazer jogos para meus sites

Stack:

• Phaser;
• TypeScript;
• Vite;
• Tiled ou LDtk;
• Kenney;
• Web Audio;
• hospedagem própria.

Projeto inicial: jogo de clicar em objetos com ranking local.

Depois:

• API de placar;
• autenticação;
• placar global;
• eventos sazonais;
• integração com RSS ou conteúdo do site.

Trilha D — Quero fazer coisas narrativas e estranhas

Stack:

• Bitsy para pequenos mundos;
• Twine para histórias ramificadas;
• Ren'Py para visual novels;
• Audacity;
• imagens próprias ou assets licenciados.

Projeto inicial: uma conversa de cinco minutos com três finais.

Trilha E — Quero estética retrô

Stack:

• GB Studio para aventura;
• PICO-8 para jogos programados;
• Pixelorama;
• BeepBox;
• ChipTone.

Projeto inicial: encontrar três objetos e escapar de uma sala.

13. Plano de estudo de 12 semanas

Semana 1 — Primeiro jogo sem arte própria

• instalar ou abrir GDevelop;
• seguir um tutorial oficial;
• criar movimentação;
• adicionar condição de vitória e derrota;
• exportar para web.

Entrega: um jogo de 30 a 90 segundos.

Semana 2 — Clonar uma mecânica simples

Escolha:

• Pong;
• Breakout;
• Flappy Bird;
• Snake;
• jogo de memória.

Entrega: clone funcional, mesmo feio.

Semana 3 — Feedback

Adicionar:

• som;
• partículas;
• tela tremendo;
• animação;
• pontuação;
• transição de telas.

Entrega: versão “mais gostosa” do jogo anterior.

Semana 4 — Projeto autoral minúsculo

Use uma mecânica conhecida com tema diferente.

Exemplo: em vez de Flappy Bird, uma impressora tenta cuspir certificados sem emperrar.

Entrega: primeiro jogo publicado no itch.io.

Semana 5 — Bitsy ou Twine

Criar uma experiência curta, com começo, meio e fim.

Entrega: jogo narrativo de cinco minutos.

Semana 6 — Godot básico

Aprender:

• nós;
• cenas;
• scripts;
• sinais;
• input;
• instâncias.

Entrega: personagem movendo e coletando objetos.

Semana 7 — Arena shooter

Adicionar:

• inimigos;
• spawn;
• projéteis;
• dano;
• pontos;
• game over.

Semana 8 — Mapas

Aprender TileMap no Godot ou usar Tiled/LDtk com sua ferramenta preferida.

Entrega: três salas conectadas.

Semana 9 — Áudio e arte própria

Criar:

• um personagem;
• dois itens;
• uma animação;
• cinco efeitos;
• um loop musical.

Semana 10 — Game jam pessoal de 48 horas

Regras:

• uma mecânica;
• uma fase;
• uma música;
• no máximo três tipos de inimigo;
• sem sistema de inventário;
• sem multiplayer;
• sem procedural desnecessário.

Semana 11 — Polimento e testes

• corrigir controles;
• melhorar instruções;
• balancear dificuldade;
• testar em outra máquina;
• pedir para alguém jogar sem explicar nada.

Semana 12 — Publicação

• página no itch.io;
• screenshots;
• GIF;
• descrição;
• controles;
• créditos;
• versão web;
• repositório;
• post-mortem curto.

14. Vinte ideias de jogos pequenos e bobos

1. Certificado Frenético — imprimir certificados sem deixar a impressora superaquecer.
2. RSS Hero — capturar notícias úteis e evitar spam.
3. Servidor em Chamas — apagar processos antes que a RAM chegue a 100%.
4. Pato Corporativo — o pato foge de reuniões e coleta café.
5. Bot Alimentador — responder mensagens corretas antes do cliente ficar bravo.
6. VPS Tetris — encaixar containers dentro de recursos limitados.
7. Fantasma do Datacenter — conversar com serviços mortos.
8. Feed Infinito — escapar de um algoritmo que nunca termina.
9. A Última Impressora — roguelike de manutenção de escritório.
10. Curso ou Golpe? — classificar anúncios educacionais absurdos.
11. Morcego do Nginx — desviar de erros 502.
12. Dieta do Tamagotchi — alimentar um bichinho que só quer fast food.
13. Biblioteca Impossível — cada livro muda a sala.
14. O Último RSS do Mundo — buscar feeds perdidos em ruínas digitais.
15. Moderador de Fediverso — separar conversa, spam e caos.
16. Botão Proibido — o jogador é instruído a não apertar um botão.
17. Reunião Infinita — sobreviver clicando nas respostas socialmente aceitáveis.
18. Arquivo Final v37 — descobrir qual versão do documento é realmente a final.
19. O Servidor que Mia — cada comando produz um comportamento absurdo.
20. Museu dos Projetos Inacabados — conversar com ideias abandonadas.

15. Ordem ideal dos primeiros dez projetos

1. Clique no alvo.
2. Pong.
3. Desviar de objetos.
4. Breakout.
5. Arena shooter.
6. Puzzle de empurrar caixas.
7. História curta no Twine.
8. Pequeno mundo no Bitsy.
9. Aventura de três salas.
10. Projeto autoral para uma game jam.

Não pule diretamente para:

• MMORPG;
• mundo aberto;
• simulador econômico completo;
• multiplayer competitivo;
• RPG de cinquenta horas;
• jogo procedural infinito;
• “meu próprio Minecraft”.

Esses projetos não são ambiciosos; para um iniciante, são formas sofisticadas de nunca terminar nada.

16. Erros que mais atrasam iniciantes

16.1 Escolher engine durante semanas

Depois de dois ou três dias, a escolha deixa de ser pesquisa e vira procrastinação.

16.2 Fazer arte antes da mecânica

Use quadrados. Se o jogo não for divertido com quadrados, um dragão desenhado à mão não resolverá.

16.3 Seguir tutorial sem modificar nada

Após cada tutorial, mude pelo menos três coisas:

• regra;
• velocidade;
• tema;
• inimigo;
• pontuação;
• controle.

16.4 Começar com plataforma

Plataforma parece simples, mas exige sensação de movimento, aceleração, gravidade, coyote time, jump buffering, colisões, slopes e câmera. Pong ou arena shooter ensinam fundamentos com menos atrito.

16.5 Criar uma arquitetura empresarial

Seu primeiro jogo não precisa de microserviços, event sourcing, Kubernetes, CQRS ou oito camadas de abstração. Ele precisa abrir e ser jogável.

16.6 Adicionar multiplayer cedo

Multiplayer multiplica bugs, estados, testes, latência e infraestrutura. Faça primeiro o jogo funcionar localmente.

16.7 Depender de IA para tudo

Use IA para:

• explicar erro;
• gerar pequenas funções;
• sugerir mecânicas;
• revisar código;
• produzir placeholders;
• converter formatos.

Não use IA para gerar um projeto inteiro que você não consegue ler. Isso produz dívida técnica antes mesmo de você possuir técnica.

16.8 Não publicar

Um jogo publicado e imperfeito ensina mais do que vinte protótipos escondidos.

17. Como avaliar qualquer engine

Antes de se comprometer, responda:

1. Exporta para a plataforma que quero?
2. O modelo de licença é aceitável?
3. Há documentação oficial atual?
4. Há exemplos completos?
5. Consigo depurar?
6. Os arquivos funcionam bem com Git?
7. A ferramenta é mantida?
8. O projeto depende de serviço online?
9. Consigo sair da ferramenta depois?
10. Há uma comunidade ativa?
11. Preciso pagar para remover limites?
12. Um jogo pequeno abre rapidamente?
13. A engine resolve meu problema ou cria outros dez?

18. Ferramentas que eu não usaria como primeira escolha

Kaboom.js

O site oficial informa que não é mais mantido. Pode ser divertido para estudar exemplos antigos, mas não é uma base sensata para um novo projeto.

Unreal para jogos bobos 2D

É como usar uma escavadeira para plantar manjericão.

Unity sem motivo específico

Ainda é poderosa, mas o peso do ambiente não ajuda o objetivo de aprender com jogos minúsculos.

Engines obscuras só porque parecem “mágicas”

Ferramentas pequenas podem desaparecer, mudar de preço ou deixar de receber correções. Para aprender, prefira projetos com documentação, exportação clara e comunidade.

Framework próprio no primeiro mês

Escrever uma engine pode ser um projeto educacional interessante. Mas não confunda “aprender a construir engines” com “aprender a terminar jogos”.

19. Kit gratuito recomendado

Kit sem código

• Engine: GDevelop
• Arte: Kenney + Pixelorama
• Mapas: editor interno
• SFX: ChipTone
• Música: Bosca Ceoil Blue
• Publicação: itch.io
• Versionamento: Git

Kit programador 2D

• Engine: Godot
• Linguagem: GDScript
• Arte: Pixelorama ou Aseprite
• Mapas: Godot TileMap ou LDtk
• SFX: ChipTone
• Música: BeepBox ou Bosca Ceoil Blue
• Publicação: itch.io e site próprio
• Versionamento: Forgejo/Git

Kit web

• Framework: Phaser
• Linguagem: TypeScript
• Build: Vite
• Mapas: Tiled
• Assets: Kenney
• Áudio: Web Audio + ChipTone
• Publicação: Nginx, Cloudflare Pages ou itch.io
• Versionamento: Forgejo/Git

Kit narrativo

• Microjogo: Bitsy
• Ficção interativa: Twine
• Visual novel: Ren'Py
• Imagem: Krita
• Áudio: Audacity
• Publicação: itch.io ou site próprio

20. Minha seleção final

Comece agora

1. GDevelop

Escolha mais pragmática para o primeiro jogo. Você aprende eventos, colisões, variáveis e estados sem travar na sintaxe.

2. Godot

Adote depois do primeiro ou segundo jogo. É a ferramenta com melhor equilíbrio entre liberdade, simplicidade, software livre e crescimento.

3. Phaser

Use em jogos pensados para seus sites, experiências compartilháveis por link e projetos integrados a APIs.

4. Bitsy e Twine

Use para ideias rápidas, narrativas e experimentais. São ferramentas que transformam uma noite livre em um trabalho terminado.

5. GB Studio ou PICO-8

Use quando as limitações retrô fizerem parte da estética, e não como uma deficiência a ser contornada.

21. Um plano concreto para hoje

Projeto: “O Último RSS do Mundo”

Ferramenta: GDevelop
Duração máxima planejada: uma sessão curta
Tela: uma arena fixa
Objetivo: coletar dez ícones de RSS
Obstáculos: blocos de spam atravessam a tela
Controles: setas ou WASD
Vitória: coletar dez feeds
Derrota: tocar em três spams
Feedback:

• som ao coletar;
• tela pisca ao tomar dano;
• contador;
• barra de três vidas;
• botão reiniciar.

Escopo proibido

• login;
• banco de dados;
• multiplayer;
• inventário;
• procedural;
• história complexa;
• editor de personagem;
• integração real com RSS;
• ranking online.

Termine a versão falsa primeiro. Integração real pode vir depois.

22. Fontes e links oficiais consultados

Engines e ferramentas

• Godot: https://godotengine.org/
• Godot – guia passo a passo: https://docs.godotengine.org/en/stable/getting_started/step_by_step/index.html
• GDevelop: https://gdevelop.io/pt-br
• GDevelop Docs: https://wiki.gdevelop.io/
• Construct 3: https://www.construct.net/en
• Construct – teste: https://www.construct.net/en/make-games/free-trial
• Scratch: https://scratch.mit.edu/about/
• Phaser Docs: https://docs.phaser.io/
• Phaser Learn: https://phaser.io/learn
• MDN Game Tutorials: https://developer.mozilla.org/en-US/docs/Games/Tutorials
• Bitsy: https://make.bitsy.org/
• Twine: https://twinery.org/
• Twine Guide: https://twinery.org/2guide
• Twine Cookbook: https://twinery.org/cookbook/
• Ren'Py: https://www.renpy.org/
• Ren'Py Quickstart: https://www.renpy.org/doc/html/quickstart.html
• GameMaker: https://gamemaker.io/pt-BR
• GameMaker Tutorials: https://gamemaker.io/en/tutorials
• GB Studio: https://www.gbstudio.dev/
• GB Studio Docs: https://www.gbstudio.dev/docs/
• PICO-8: https://www.lexaloffle.com/pico-8.php
• PICO-8 Manual: https://www.lexaloffle.com/dl/docs/pico-8_manual.html
• microStudio: https://microstudio.dev/pt/
• Pygame Docs: https://www.pygame.org/docs/
• LÖVE: https://love2d.org/
• Defold: https://defold.com/
• Defold Tutorials: https://defold.com/tutorials/
• Unity – primeiros passos: https://docs.unity3d.com/6000.3/Documentation/Manual/first-time-user.html
• RPG Maker: https://www.rpgmakerweb.com/
• Rosebud AI: https://rosebud.ai/
• Buildbox: https://www.buildbox.com/
• Kaboom.js – aviso de descontinuação: https://kaboomjs.com/

Arte e mapas

• Kenney: https://kenney.nl/assets
• OpenGameArt: https://opengameart.org/
• Aseprite: https://www.aseprite.org/
• LibreSprite: https://libresprite.github.io/
• Pixelorama: https://pixelorama.org/
• Tiled: https://www.mapeditor.org/
• Tiled Docs: https://doc.mapeditor.org/
• LDtk: https://ldtk.io/
• Game-icons.net: https://game-icons.net/

Áudio

• ChipTone: https://sfbgames.itch.io/chiptone
• jsfxr: https://sfxr.me/
• Bfxr: https://www.bfxr.net/
• Bosca Ceoil Blue: https://github.com/YuriSizov/boscaceoil-blue
• BeepBox: https://www.beepbox.co/
• Freesound: https://freesound.org/
• Freesound FAQ: https://freesound.org/help/faq/

Publicação e comunidade

• itch.io – primeiros passos: https://itch.io/docs/creators/getting-started
• itch.io – jogos HTML5: https://itch.io/docs/creators/html5
• itch.io – game jams: https://itch.io/jams
• GDQuest: https://www.gdquest.com/
• GDQuest – trilha Godot para iniciantes: https://www.gdquest.com/tutorial/godot/learning-paths/beginner/

Conclusão

A ferramenta não é o problema principal. O problema é escopo.

Use GDevelop para terminar algo imediatamente, Godot para construir competência de longo prazo e Phaser para aproveitar sua experiência web. Bitsy, Twine, GB Studio e PICO-8 servem como laboratórios criativos onde limitações ajudam em vez de atrapalhar.

A meta inicial não deve ser “aprender desenvolvimento de jogos”. Isso é amplo demais. A meta deve ser:

Publicar dez jogos minúsculos, cada um ensinando uma única coisa.

Depois do décimo, você não estará mais tentando descobrir se consegue criar jogos. Estará escolhendo qual jogo vale a pena criar.