A Unity continua a ser o motor de jogos mais usado em mobile e um dos mais procurados por quem quer aprender a programar jogos do zero. Este tutorial mostra, passo a passo, como instalar a Unity 6.5, criar um projeto 3D completo com personagem, física, coletáveis, interface e build final, tudo em cerca de 90 minutos. No final vais ter um jogo funcional e pronto a exportar para PC ou Android.

Não precisas de experiência prévia em desenvolvimento de jogos para acompanhar este guia. Precisas apenas de um computador que cumpra os requisitos mínimos, cerca de 15 GB de espaço livre em disco e vontade de errar algumas vezes antes de teres tudo a funcionar. Cada script vem explicado linha a linha, e a secção de resolução de problemas cobre os erros mais comuns de quem instala a Unity pela primeira vez.

Porque aprender Unity em 2026

A polémica da “Runtime Fee” de 2023 deixou uma marca na reputação da Unity, mas a empresa recuou por completo em setembro de 2024, abolindo a cobrança por instalação depois de admitir publicamente que o modelo tinha sido um erro, segundo noticiou a BBC na altura do anúncio original. Em 2026 o motor está num momento diferente: a linha Unity 6.x amadureceu, a Unity Hub chegou à versão 3.16 e a empresa investe pesado em compilação mais rápida e ferramentas de produtividade.

Vale a pena aprender Unity porque continua a dominar o mercado mobile, onde alimenta cerca de 68,5% dos principais títulos, segundo dados de mercado de 2026 recolhidos pela VoxBooster. É também o motor com a curva de entrada mais suave para quem já sabe programar em C#, e tem uma das maiores bibliotecas de tutoriais e assets da indústria. Se procuras um tutorial de Unity estruturado, este guia cobre desde a instalação até à exportação de um jogo jogável.

Há ainda um fator prático que pesa a favor da Unity: a Asset Store. É uma loja integrada no próprio Editor onde qualquer pessoa pode descarregar modelos 3D, texturas, sistemas de animação ou pacotes de código prontos a usar, muitos deles gratuitos. Para quem está a aprender, isto significa que não precisas de criar tudo do zero para teres um protótipo com aspeto profissional. O Unity Learn, a plataforma oficial de formação, junta ainda centenas de tutoriais gratuitos organizados por nível de experiência, o que ajuda bastante depois de terminares este guia introdutório.

Unity 6.5 explicado: LTS, Tech Stream e o que mudou

A Unity distribui o motor em duas linhas paralelas. A Unity 6.0 LTS é a versão de suporte alargado, recomendada para quem quer estabilidade num projeto que vai demorar meses a terminar. A Unity 6.5, atualizada em agosto de 2026 segundo a documentação oficial, é a versão Tech Stream mais recente e traz as funcionalidades mais novas, ainda que com menos garantias de estabilidade a longo prazo. Para este tutorial qualquer uma serve, mas se és iniciante recomendamos a LTS.

Entre as novidades mais relevantes da geração 6.x está a integração mais profunda com o runtime CoreCLR, que segundo um resumo de notícias de desenvolvimento de julho de 2026 reduz o tempo de compilação de shaders em até 90% em determinados cenários. A Unity Hub 3.16, lançada em setembro de 2026, adicionou um novo SDK de licenciamento, suporte para builds xLTS e sugestões automáticas de tags de projeto. A empresa também publicou o projeto de amostra oficial “Bunny Blitz”, pensado para ensinar boas práticas 2D e 3D na mesma base de código.

Para quem vem de versões mais antigas, a mudança mais sentida no dia a dia não é uma funcionalidade isolada, mas sim a velocidade. Projetos que antes demoravam minutos a compilar depois de uma alteração em shaders agora reagem quase de imediato, o que reduz bastante a frustração de quem está a testar pequenos ajustes repetidamente. Isto importa especialmente num tutorial como este, em que vais alternar constantemente entre escrever código e carregar em “Play” para testar.

Unity vs Unreal Engine vs Godot: qual escolher em 2026

O panorama dos motores de jogos mudou de forma visível nos últimos dois anos. Segundo o inquérito “State of the Game Industry” apresentado na GDC 2026, o Unreal Engine ultrapassou pela primeira vez a Unity como motor principal entre programadores profissionais, com 42% a indicar o motor da Epic Games contra 30% para a Unity. Já em número de lançamentos na Steam, a Unity continua à frente: análises baseadas em dados do SteamDB apontam para 35% a 38% dos novos jogos lançados em 2026 a correrem sobre Unity, contra 18% a 22% para Unreal e uma fatia crescente de 8% a 10% para a Godot, motor open source que praticamente triplicou a sua presença desde 2024.

CritérioUnityUnreal EngineGodot
Linguagem principalC#C++ / BlueprintsGDScript / C#
LicençaGrátis até certo volume, depois subscrição ProGrátis, royalties acima de $1M de receitaGrátis e open source (MIT)
Ponto forteMobile e projetos indie 2D/3DGráficos AAA e projetos next-genProjetos leves e comunidade open source
Quota em lançamentos Steam (2026)35% a 38%18% a 22%8% a 10%
Quota em mobile (2026)~68,5% dos títulos topReduzidaEm crescimento

Para quem está a começar do zero, a Unity continua a ser a escolha mais prática: tem mais tutoriais em português, mais assets prontos na Asset Store e integra-se bem com dispositivos móveis, que é onde a maioria dos programadores indie lança o primeiro projeto.

Vale também referir a GameMaker, que continua a ter uma fatia relevante entre criadores de jogos 2D mais simples, embora com adoção bem menor do que as três opções da tabela acima. Se o teu objetivo é 3D ou um jogo 2D com física mais complexa, a escolha realista está entre Unity, Unreal e Godot.

Pré-requisitos: hardware, software e conhecimentos

Antes de instalar seja o que for, confirma que a tua máquina cumpre os requisitos mínimos documentados pela própria Unity para a versão 6.5. Não precisas de ser programador experiente, mas noções básicas de lógica (variáveis, condições, ciclos) tornam o processo muito mais rápido.

RequisitoWindowsmacOSLinux
Sistema operativoWindows 10 21H1 (build 19043) ou superiormacOS Ventura 13 ou superiorDistribuições recentes com suporte Vulkan
CPUx64 com SSE2 ou Arm64Apple Silicon (M1+) recomendadox64 com SSE2
GPUCompatível com DX10, DX11, DX12 ou VulkanCompatível com MetalCompatível com Vulkan
RAM mínima8 GB (16 GB recomendado)8 GB (16 GB recomendado)8 GB (16 GB recomendado)
Espaço em disco~15 GB por versão do Editor instalada~15 GB por versão do Editor instalada~15 GB por versão do Editor instalada

Vais também precisar de uma conta Unity gratuita (para ativar a licença Personal) e de cerca de 90 minutos livres para acompanhar todos os passos até teres um jogo jogável.

Os valores da tabela são o mínimo absoluto para o Editor abrir e correr. Na prática, para um projeto 3D com alguma dimensão vais sentir-te bem mais confortável com 16 GB de RAM e um disco SSD, já que a Unity lê e escreve muitos ficheiros pequenos durante a importação de assets e a compilação de scripts. Um disco mecânico antigo torna esse processo visivelmente mais lento, mesmo que o resto do hardware cumpra os requisitos.

Passo 1 e 2: Instala o Unity Hub e o Editor

O Unity Hub é a aplicação que gere as versões do Editor instaladas, os teus projetos e a licença. Vai a learn.unity.com ou ao site oficial da Unity, descarrega o instalador do Hub para o teu sistema operativo e segue o assistente de instalação padrão.

  • Abre o Unity Hub depois de instalado e inicia sessão com uma conta Unity (cria uma gratuitamente se não tiveres).
  • No separador “Installs”, clica em “Install Editor”.
  • Escolhe a Unity 6.0 LTS se preferires estabilidade, ou a Unity 6.5 se quiseres as funcionalidades mais recentes de compilação e animação.
  • Nos módulos adicionais, marca pelo menos “Android Build Support” e “WebGL Build Support” se quiseres testar exportação multiplataforma mais tarde.
  • Confirma e espera pela instalação. Pode demorar entre 15 e 30 minutos dependendo da ligação à internet.

Uma vantagem do Unity Hub é que consegues ter várias versões do Editor instaladas ao mesmo tempo, sem que uma interfira com a outra. Isto é útil quando trabalhas em vários projetos: um pode ficar preso à Unity 6.0 LTS por estabilidade, enquanto experimentas a Unity 6.5 num projeto novo. Ao criares um projeto, o Hub associa automaticamente a versão do Editor usada, por isso não há risco de abrires um projeto antigo com a versão errada por engano.

Passo 3: Cria o teu primeiro projeto 3D

Com o Editor instalado, volta ao separador “Projects” no Hub e clica em “New Project”. Escolhe o template 3D (URP), que já vem com o Universal Render Pipeline configurado e é o mais indicado para projetos novos em 2026. Dá um nome ao projeto, por exemplo “MeuPrimeiroJogo3D”, escolhe a pasta de destino e clica em “Create Project”. A primeira abertura pode demorar alguns minutos enquanto a Unity importa os pacotes base.

Repara que o Hub também oferece templates “2D (URP)” e “HDRP”, além de opções de realidade virtual. O URP (Universal Render Pipeline) equilibra qualidade visual e desempenho, e funciona bem tanto em PC como em telemóvel, por isso é a escolha certa para praticamente todos os projetos novos. O HDRP (High Definition Render Pipeline) só compensa em jogos muito exigentes visualmente, destinados a PC ou consola de gama alta, e tem um custo de desempenho que não faz sentido para um primeiro projeto.

Passo 4: Conhece a interface do Unity

Antes de avançar, vale a pena perceber os cinco painéis principais que vais usar constantemente. A janela Scene mostra o mundo do jogo em 3D e é onde posicionas objetos. A janela Game mostra o que o jogador vai ver através da câmara ativa. A Hierarchy lista todos os objetos (GameObjects) presentes na cena atual. O Inspector mostra e permite editar as propriedades e componentes do objeto selecionado. Por fim, a janela Project mostra todos os ficheiros e assets do teu projeto, incluindo scripts, materiais e prefabs.

Um erro comum de quem começa agora é mexer diretamente na janela Game em vez da Scene, ou esquecer-se de guardar a cena depois de fazer alterações (Ctrl+S ou Cmd+S). Habitua-te a guardar com frequência desde já.

Existe ainda uma sexta janela que vais consultar sempre que algo correr mal: a Console (Window → General → Console). É lá que aparecem os erros de compilação, avisos e as mensagens que escreveres com Debug.Log no código. Sempre que um script não funcionar como esperado, o primeiro sítio a verificar é sempre a Console, não o comportamento visual do jogo.

Passo 5 e 6: Constrói o cenário e cria o jogador

Vamos montar a cena base. No menu GameObject → 3D Object → Plane, cria um plano e posiciona-o em (0, 0, 0) através do Inspector: este vai ser o chão. Aumenta a escala para algo como (5, 1, 5) para teres espaço suficiente para o jogador se mover.

De seguida cria o jogador: GameObject → 3D Object → Capsule. Renomeia o objeto para “Player” na Hierarchy e posiciona-o um pouco acima do chão, por exemplo em (0, 1, 0). No Inspector, clica em “Add Component” e adiciona um Rigidbody, que vai dar física ao jogador (gravidade, colisões, massa). O Capsule já vem com um Capsule Collider por defeito, por isso não precisas de o adicionar manualmente.

Por fim, adiciona uma luz direcional (se o template URP não tiver criado uma automaticamente) através de GameObject → Light → Directional Light, para o cenário não ficar completamente escuro.

Antes de avançares para o código, vale a pena ajustar as constraints do Rigidbody do jogador. No Inspector, dentro do componente Rigidbody, expande “Constraints” e marca “Freeze Rotation” nos eixos X e Z. Sem isto, a cápsula tende a tombar de lado quando colide com outros objetos, um comportamento que confunde muita gente que está a testar o movimento pela primeira vez e acha que o problema está no script.

Passo 7: Programa o movimento do jogador em C#

Na janela Project, clica com o botão direito, escolhe Create → C# Script e chama-lhe “PlayerController”. Faz duplo clique para abrir no editor de código (normalmente Visual Studio ou Rider) e substitui o conteúdo por este script de movimento básico:

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float speed = 5f;
    private Rigidbody rb;

    void Start()
    {
        rb = GetComponent<Rigidbody>();
    }

    void Update()
    {
        float h = Input.GetAxis("Horizontal");
        float v = Input.GetAxis("Vertical");

        Vector3 direction = new Vector3(h, 0, v);
        Vector3 velocity = direction * speed;

        rb.MovePosition(transform.position + velocity * Time.deltaTime);
    }
}

Vale a pena perceber o que cada parte deste script faz. O método Start() corre uma única vez quando o objeto entra em cena e guarda a referência ao componente Rigidbody. O método Update() corre em todos os frames e lê o valor dos eixos horizontal e vertical através de Input.GetAxis, que devolve um número entre -1 e 1 conforme premes as setas ou o WASD. Multiplicamos essa direção pela velocidade e por Time.deltaTime, o tempo decorrido desde o último frame, para que o movimento seja igual independentemente da taxa de fotogramas da máquina onde o jogo corre.

Guarda o script, volta ao Editor, arrasta o ficheiro “PlayerController” da janela Project para o objeto “Player” na Hierarchy (ou usa “Add Component” no Inspector). Carrega em “Play” no topo da janela para testar: deves conseguir mover a cápsula com as setas ou WASD. Se nada acontecer, confirma que o script está mesmo anexado ao objeto certo, o erro mais comum nesta fase.

Passo 8: Configura a câmara de perseguição

Sem uma câmara que siga o jogador, o objeto vai sair do enquadramento assim que se mover. Cria um novo script “CameraFollow” e anexa-o à câmara principal (Main Camera) na Hierarchy:

using UnityEngine;

public class CameraFollow : MonoBehaviour
{
    public Transform target;
    public Vector3 offset = new Vector3(0, 5, -8);
    public float smoothSpeed = 5f;

    void LateUpdate()
    {
        if (target == null) return;

        Vector3 desiredPosition = target.position + offset;
        transform.position = Vector3.Lerp(transform.position, desiredPosition, smoothSpeed * Time.deltaTime);
        transform.LookAt(target);
    }
}

No Inspector da câmara, arrasta o objeto “Player” para o campo “Target” do script. Carrega em Play novamente: a câmara deve agora seguir o jogador suavemente, mantendo-o sempre visível.

Repara que este script usa LateUpdate() em vez de Update(). A diferença é subtil mas importante: LateUpdate corre depois de todos os Update do frame terem terminado, garantindo que a câmara só se move depois do jogador já ter a posição final naquele frame. Se usasses Update aqui, a câmara podia “tremer” ligeiramente por vezes se calcular a posição do jogador um instante antes deste terminar de se mover. A função Vector3.Lerp interpola suavemente entre a posição atual da câmara e a posição desejada, o que produz aquele efeito de câmara “elástica” comum em jogos de plataformas e ação.

Passo 9: Adiciona obstáculos e coletáveis

Cria algumas esferas (GameObject → 3D Object → Sphere) espalhadas pelo cenário para servirem de moedas coletáveis. Em cada uma, marca a opção “Is Trigger” no respetivo Sphere Collider (Inspector), para que o jogador atravesse o objeto em vez de bater nele. Cria um script “Collectible” e anexa-o a cada esfera:

using UnityEngine;

public class Collectible : MonoBehaviour
{
    public static int score = 0;

    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            score++;
            Debug.Log("Pontuação: " + score);
            Destroy(gameObject);
        }
    }
}

Confirma que o objeto “Player” tem a tag “Player” atribuída (dropdown “Tag” no topo do Inspector). Sem essa tag, a condição CompareTag nunca se verifica e o coletável não desaparece nem soma pontos, um dos erros mais frequentes nesta fase do tutorial.

Se a tag “Player” ainda não existir na lista, cria-a através do próprio dropdown: seleciona “Add Tag”, clica no símbolo “+” e escreve o nome exato “Player” (com maiúscula inicial, já que a comparação de texto no código é sensível a maiúsculas e minúsculas). Só depois voltas ao objeto Player na Hierarchy e atribuis a tag recém-criada.

Passo 10: Cria a interface (UI) e a pontuação

Vai a GameObject → UI → Text – TextMeshPro (aceita importar os recursos TMP essenciais se for pedido). Isto cria automaticamente um Canvas com um elemento de texto lá dentro. Renomeia o texto para “ScoreText” e posiciona-o no canto superior esquerdo do ecrã através do Rect Transform. Cria depois um script “GameUI” e anexa-o ao próprio objeto de texto:

using UnityEngine;
using TMPro;

public class GameUI : MonoBehaviour
{
    private TextMeshProUGUI scoreText;

    void Start()
    {
        scoreText = GetComponent<TextMeshProUGUI>();
    }

    void Update()
    {
        scoreText.text = "Pontos: " + Collectible.score;
    }
}

Corre o jogo e recolhe algumas moedas: o texto no ecrã deve atualizar-se em tempo real com a pontuação acumulada.

Se o texto não aparecer no ecrã, verifica o “Render Mode” do Canvas (deve estar em “Screen Space – Overlay” por defeito) e confirma que a posição do elemento de texto, definida pelo Rect Transform, não ficou fora dos limites visíveis da câmara. É comum arrastar acidentalmente o texto para fora da área do Canvas ao reposicioná-lo manualmente, e nesse caso ele continua a atualizar-se, só que fora do que a câmara mostra.

Passo 11 e 12: Som, menus e build final

Para som, adiciona um componente Audio Source ao objeto “Player” e arrasta um ficheiro de áudio curto (formato WAV ou MP3) para o campo “AudioClip”. Chama GetComponent<AudioSource>().Play() dentro do script “Collectible” sempre que uma moeda for apanhada, para dar feedback sonoro.

Para o menu inicial e ecrã de fim de jogo, cria duas novas cenas através de File → New Scene, chama-lhes “MainMenu” e “GameOver”, e adiciona-as em File → Build Settings → Scenes in Build junto com a cena principal. Um botão simples com este script troca de cena:

using UnityEngine;
using UnityEngine.SceneManagement;

public class MenuManager : MonoBehaviour
{
    public void IniciarJogo()
    {
        SceneManager.LoadScene("GameScene");
    }

    public void VoltarAoMenu()
    {
        SceneManager.LoadScene("MainMenu");
    }
}

Para finalizar, abre File → Build Settings, escolhe a plataforma alvo (PC, Mac & Linux Standalone ou Android), clica em “Switch Platform” se necessário e depois em “Build”. A Unity vai gerar um executável pronto a distribuir. Se escolheres Android, precisas de ter o Android SDK e NDK instalados, algo que o próprio Hub consegue descarregar automaticamente através do instalador de módulos.

Antes de gerares o build final, entra em Edit → Project Settings → Player e preenche pelo menos o nome do produto, o nome da empresa e o ícone da aplicação. Estes campos não afetam a jogabilidade, mas são obrigatórios em algumas plataformas de distribuição e evitam que o teu jogo apareça com o nome genérico “DefaultCompany” quando outra pessoa o instalar.

Erros comuns ao aprender Unity

Estes são os enganos mais frequentes de quem está a dar os primeiros passos com o motor, recolhidos a partir de padrões documentados pela própria comunidade Unity.

  • Esquecer de anexar o script ao objeto. O código compila sem erros, mas nada acontece porque o componente nunca foi arrastado para a Hierarchy.
  • Mover objetos com física através de transform.position. Isto ignora colisões. Usa sempre Rigidbody.MovePosition ou AddForce quando o objeto tem um Rigidbody.
  • Escalas fora do normal. Objetos com escala 1000 ou 0,001 causam problemas de iluminação, física e precisão de câmara.
  • Lógica de física dentro de Update em vez de FixedUpdate. Isto produz movimento inconsistente conforme a taxa de fotogramas varia.
  • Não guardar a cena. Fechar o Editor sem Ctrl+S faz “desaparecer” horas de trabalho na cena ativa.
  • Ignorar Tags e Layers. Sem a tag correta atribuída, condições como CompareTag e deteção de colisões seletivas simplesmente não funcionam.
  • Deixar a hierarquia desorganizada. Uma cena cheia de objetos chamados “Cube”, “Cube (1)”, “Cube (2)” torna a depuração muito mais lenta à medida que o projeto cresce. Renomeia os objetos assim que os crias.
  • Testar só na própria máquina. Um jogo que corre bem no computador de desenvolvimento pode arrastar-se num telemóvel de gama média por causa de texturas grandes ou iluminação em tempo real mal otimizada. Testa sempre no dispositivo alvo antes de considerares o projeto terminado.

Resolução de problemas: 8 situações frequentes

A tabela seguinte reúne os problemas que mais aparecem em fóruns e comunidades de programadores a dar os primeiros passos com este motor, com a causa mais provável e a forma de resolver cada um sem perder tempo a adivinhar.

ProblemaCausa provávelSolução
Erro “NullReferenceException”Uma referência (Transform, componente) não foi atribuída no InspectorConfirma que todos os campos públicos do script estão preenchidos na cena
Personagem atravessa o chãoFalta um Collider no plano ou o Rigidbody está mal configuradoVerifica se o Plane tem Mesh Collider e se o Player usa Rigidbody, não apenas Transform
Câmara não segue o jogadorCampo “Target” vazio no script CameraFollowArrasta o objeto Player para o campo Target no Inspector da câmara
Coletável não desapareceTag “Player” não atribuída ou Collider sem “Is Trigger”Confirma a tag do jogador e ativa “Is Trigger” no Collider do coletável
Build falha para AndroidSDK/NDK do Android não instaladoNo Unity Hub, adiciona o módulo “Android Build Support” com SDK e NDK
FPS baixo em dispositivos móveisIluminação em tempo real ou texturas demasiado grandesUsa Baked Lighting e reduz a resolução das texturas para exportação mobile
Texto TMP não apareceRecursos essenciais do TextMeshPro não importadosAceita o pedido de importação “TMP Essentials” na primeira utilização
Script não compilaErro de sintaxe ou nome de classe diferente do nome do ficheiroVerifica a consola de erros e garante que o nome da classe é igual ao do ficheiro .cs

Se depois de percorreres esta lista o problema persistir, o próximo passo é isolar a cena: cria um projeto novo e replica só a parte que falha, com o mínimo de objetos possível. Isto ajuda a perceber se o erro vem de uma configuração específica do teu projeto ou de um comportamento genuíno do motor, e é também a forma mais eficaz de pedir ajuda em fóruns, já que outras pessoas conseguem reproduzir o problema com facilidade.

Dicas avançadas para otimizar o teu jogo

Depois de teres o essencial a funcionar, há um conjunto de práticas que fazem diferença real em projetos maiores. Usa Object Pooling em vez de instanciar e destruir objetos repetidamente (como balas ou inimigos), já que Instantiate e Destroy são operações relativamente pesadas quando chamadas com frequência. Aproveita o Profiler integrado (Window → Analysis → Profiler) para identificar exatamente que script ou operação está a consumir mais tempo de CPU por frame.

Se o teu projeto for para mobile, ativa a compressão de texturas apropriada por plataforma (ASTC para Android moderno, por exemplo) e considera usar o Universal Render Pipeline em modo “Mobile” para reduzir o custo de shaders. Para projetos maiores, vale também a pena experimentar o novo Input System da Unity em vez do sistema legado usado neste tutorial, já que suporta múltiplos dispositivos (comando, teclado, ecrã tátil) com o mesmo código.

Outra prática que compensa desde o primeiro dia é usar controlo de versões com Git. A Unity gera muitos ficheiros binários e de configuração que não fazem sentido num repositório, por isso vale a pena aplicar um ficheiro .gitignore específico para projetos Unity (há vários templates gratuitos e amplamente usados pela comunidade) e ativar o modo “Visible Meta Files” em Edit → Project Settings → Editor, na opção “Version Control”. Isto evita conflitos difíceis de resolver quando trabalhas em equipa ou simplesmente quando queres poder voltar atrás numa alteração que correu mal.

Onde publicar o teu jogo depois do build

Depois de teres um build funcional, o passo seguinte é escolheres onde o distribuir. Para projetos indie e protótipos, o itch.io continua a ser a plataforma mais simples: a conta é gratuita, o processo de publicação demora minutos e podes escolher se o jogo fica gratuito, pago ou “paga o que quiseres”. Não há barreira de entrada nem processo de aprovação, o que o torna ideal para publicares o teu primeiro projeto e recolheres feedback real de jogadores.

Se o teu build for para Android, a Google Play Console permite testes internos e fechados antes de um lançamento público, o que é útil para apanhares bugs que só aparecem em dispositivos físicos diferentes do teu. Para projetos mais ambiciosos, com maior produção e intenção comercial séria, a Steam através do Steamworks é a rota mais procurada por estúdios indie, mas exige uma taxa de registo única por jogo e um processo de revisão mais longo do que o itch.io. Começa pelo itch.io ou por testes fechados no Android antes de avançares para uma loja maior. É a forma mais rápida de validar se o teu jogo tem mesmo interesse antes de investires tempo em polimento adicional.

O panorama da Unity em 2026: preços e Runtime Fee

Depois do cancelamento total da Runtime Fee em 2024, a Unity voltou a um modelo de negócio mais previsível baseado em subscrições. Segundo um artigo publicado em agosto de 2026, os planos Pro e Enterprise sofreram um novo aumento de preço de cerca de 5% a 12 de janeiro de 2026, mas continuam sem qualquer cobrança por instalação de jogo. Para a esmagadora maioria dos programadores indie que usam a licença Personal (gratuita até um determinado limite de receita anual), nada disto tem impacto direto no bolso.

O mercado global de motores de jogos foi avaliado em cerca de $5,20 mil milhões em 2026, segundo dados recolhidos pela VoxBooster, com a Unity a manter a liderança em número absoluto de jogos publicados na Steam (48,2%) apesar da perda de terreno para o Unreal Engine entre estúdios profissionais que escolhem um motor principal.

Vale relembrar como se chegou aqui. Em setembro de 2023, a Unity anunciou uma taxa cobrada por cada instalação do jogo acima de determinados limites, uma decisão que gerou uma onda de críticas tão forte que levou à saída do então CEO John Riccitiello. Um ano depois, em setembro de 2024, a empresa reconheceu publicamente o erro e eliminou a taxa por completo, segundo noticiou a Yahoo Finance na altura. Desde então, o discurso da liderança da Unity tem sido o de voltar a um ciclo de preços mais previsível e alinhado com o resto da indústria de software, com revisões anuais em vez de mudanças súbitas de modelo de negócio.

O projeto completo que construíste

Ao seguires todos os passos acima, ficaste com um projeto Unity funcional composto pelos seguintes ficheiros e cenas, pronto a expandir ou a usar como base de aprendizagem.

Ficheiro / CenaFunção
GameScene.unityCena principal com chão, jogador, câmara e coletáveis
MainMenu.unityEcrã inicial com botão para começar o jogo
GameOver.unityEcrã final com botão para voltar ao menu
PlayerController.csMovimento do jogador com física (Rigidbody)
CameraFollow.csCâmara de perseguição suave
Collectible.csLógica de pontuação e destruição do coletável
GameUI.csAtualização do texto de pontuação em tempo real
MenuManager.csNavegação entre cenas (menu, jogo, game over)

A partir daqui, os próximos passos naturais são adicionar inimigos com inteligência artificial simples, um sistema de vidas, e experimentar o pacote Cinemachine para câmaras mais sofisticadas do que o script manual usado neste tutorial. A documentação oficial da Unity Manual é a melhor referência para aprofundar cada um destes componentes.

Perguntas frequentes

A Unity é gratuita?
Sim, a licença Personal é gratuita para programadores individuais e pequenas equipas até um determinado limite de receita anual. Acima disso é necessário migrar para os planos Pro ou Enterprise, pagos por subscrição.

Preciso de saber programar para usar a Unity?
Não precisas de ser um programador experiente, mas conhecimentos básicos de lógica em C# ajudam muito. Este tutorial assume que consegues ler e adaptar pequenos blocos de código.

Qual a diferença entre Unity LTS e Tech Stream?
A LTS (Long Term Support) recebe apenas correções de bugs e é indicada para produção estável. A Tech Stream recebe novas funcionalidades primeiro, mas com menos garantias de estabilidade a longo prazo.

Consigo exportar o mesmo projeto para PC e Android?
Sim. Basta trocar a plataforma alvo em File → Build Settings e garantir que tens os módulos de build corretos instalados através do Unity Hub.

A Unity ainda cobra por cada instalação do jogo (Runtime Fee)?
Não. A Unity cancelou por completo essa cobrança em setembro de 2024, depois da forte reação negativa da comunidade em 2023.

Devo escolher Unity, Unreal Engine ou Godot?
Depende do objetivo. A Unity é a opção mais equilibrada para mobile e projetos indie 2D/3D. O Unreal Engine é mais forte em projetos AAA com gráficos avançados. A Godot é totalmente open source e cada vez mais popular entre programadores indie que valorizam leveza e ausência de licenciamento.

Quanto tempo demora a aprender o básico da Unity?
Seguindo este tutorial consegues ter um protótipo jogável em cerca de 90 minutos. Para dominar conceitos mais avançados como shaders, animação ou multiplayer, conta com várias semanas de prática regular.

Preciso de pagar para publicar um jogo feito em Unity?
Não necessariamente. Publicar no itch.io é gratuito e a licença Personal da Unity não cobra royalties sobre as vendas. Só pagarás taxas específicas se optares por lojas como a Steam, que cobram um valor de registo único por jogo, ou se a tua receita anual ultrapassar o limite da licença Personal, obrigando-te a mudar para um plano Pro pago por subscrição.

Onde encontro mais projetos de exemplo oficiais?
A própria Unity publica projetos de amostra através do Unity Learn, incluindo o recente “Bunny Blitz”, pensado especificamente para ensinar fluxos de trabalho 2D e 3D combinados.