Sistema Operacional para PCs e Dispositivos Móveis:

 

Projetando um Sistema Operacional para PCs e Dispositivos Móveis: Como Começar com um Setup Econômico

Criar um sistema operacional do zero é um dos projetos mais interessantes e desafiadores da computação. O desenvolvimento envolve programação de baixo nível, arquitetura de computadores, gerenciamento de memória, drivers, sistemas de arquivos, segurança e interfaces gráficas.

Embora pareça um trabalho reservado às grandes empresas de tecnologia, é perfeitamente possível criar um sistema operacional experimental ou educacional utilizando um computador comum, ferramentas gratuitas e emuladores.

O segredo está em começar pequeno.

Neste artigo, vamos apresentar um caminho prático para desenvolver um sistema operacional que possa evoluir para diferentes tipos de hardware, desde PCs antigos até computadores modernos e, posteriormente, dispositivos baseados em ARM.

1. Primeiro passo: definir o objetivo do sistema

Antes de começar a programar, é importante responder a uma pergunta:

O que esse sistema operacional deverá fazer?

Criar um SO completo, capaz de competir com Windows, Linux, Android ou macOS, é um projeto gigantesco. Para um desenvolvedor independente, o melhor caminho é dividir o projeto em etapas.

Sistema operacional educacional

Uma primeira versão pode ter apenas:

  • Bootloader;
  • Kernel;
  • Gerenciamento básico de memória;
  • Teclado;
  • Tela;
  • Shell;
  • Sistema simples de arquivos;
  • Escalonador de tarefas.

O objetivo não é substituir o Windows ou o Linux, mas entender como um sistema operacional funciona internamente.

2. Criar um sistema para computadores antigos

Outra possibilidade é desenvolver um sistema extremamente leve para computadores antigos.

Nesse caso, o objetivo seria reduzir:

  • consumo de RAM;
  • uso de CPU;
  • quantidade de processos;
  • espaço ocupado no armazenamento;
  • tempo de inicialização.

Entretanto, existe uma diferença importante:

Criar um sistema do zero é muito mais trabalhoso do que criar uma distribuição Linux leve.

Se a intenção for simplesmente recuperar um computador antigo para uso cotidiano, uma distribuição Linux minimalista normalmente será uma escolha mais prática.

Projetos como antiX, Tiny Core Linux e outras distribuições leves podem servir como referência para estudar otimização de sistemas.

3. E quanto aos celulares?

Aqui existe um desafio adicional.

Um sistema operacional para PC não pode simplesmente ser instalado em qualquer celular.

Smartphones utilizam diferentes:

  • processadores;
  • bootloaders;
  • controladores;
  • telas;
  • modems;
  • GPUs;
  • câmeras;
  • sistemas de armazenamento;
  • mecanismos de segurança.

Por isso, desenvolver um SO para smartphones exige inicialmente escolher um modelo específico de aparelho.

Uma estratégia muito mais realista é começar com uma placa de desenvolvimento ARM, um computador de placa única ou um dispositivo cuja documentação de hardware esteja disponível.

Depois que o kernel funcionar em uma plataforma, pode-se trabalhar na portabilidade para outras arquiteturas.

4. Escolhendo a arquitetura

As arquiteturas mais interessantes para um projeto desse tipo são:

x86/x86-64

É uma excelente opção para começar no mundo dos PCs.

Você poderá testar o sistema em:

  • computadores antigos;
  • computadores modernos;
  • máquinas virtuais;
  • QEMU;
  • VirtualBox, dependendo do projeto.

Para um primeiro SO de hobby, x86 ou x86-64 é provavelmente o caminho mais simples.

ARM

ARM é extremamente importante em:

  • smartphones;
  • tablets;
  • sistemas embarcados;
  • Raspberry Pi;
  • dispositivos IoT.

Porém, ARM não significa automaticamente compatibilidade entre todos os dispositivos. Cada plataforma pode exigir diferentes drivers e mecanismos de inicialização.

RISC-V

RISC-V é uma arquitetura aberta que vem ganhando espaço no desenvolvimento acadêmico, embarcado e experimental.

Ela é particularmente interessante para quem deseja estudar arquitetura de processadores e desenvolver sistemas de baixo nível.

5. Use QEMU antes de comprar hardware

Uma das melhores decisões para economizar dinheiro é utilizar um emulador.

O QEMU permite executar sistemas operacionais experimentais sem precisar instalar imediatamente o código em um computador físico.

Isso possibilita testar:

  • bootloader;
  • kernel;
  • memória;
  • interrupções;
  • teclado;
  • armazenamento;
  • sistemas de arquivos;
  • processos;
  • drivers.

Assim, você pode fazer dezenas ou centenas de testes sem correr o risco de danificar o sistema operacional do computador principal.

6. O que você precisa para começar?

Um setup econômico pode ser bastante simples.

Hardware

Um computador relativamente comum já pode servir para desenvolvimento.

Não é necessário possuir uma máquina extremamente potente.

Por exemplo:

PC principal

  • processador Intel ou AMD;
  • 4 GB de RAM ou mais;
  • SSD ou HD;
  • Linux, Windows ou outro sistema compatível com as ferramentas utilizadas.

Computador antigo para testes

Pode ser utilizado posteriormente para testar compatibilidade com hardware real.

Placa ARM/RISC-V

Pode ser adicionada quando o projeto estiver mais avançado.

7. Ferramentas gratuitas

Grande parte do ambiente de desenvolvimento pode ser construída com software livre.

GCC

O GCC é um dos compiladores mais importantes para desenvolvimento de sistemas.

Em projetos de sistemas operacionais, normalmente utiliza-se um cross-compiler, permitindo gerar código para uma arquitetura diferente da máquina utilizada para desenvolvimento.

Binutils

As ferramentas GNU Binutils incluem programas importantes como:

  • assembler;
  • linker;
  • objcopy;
  • objdump.

Elas são fundamentais para trabalhar próximo ao hardware.

QEMU

É utilizado para executar e testar o sistema operacional virtualmente.

GDB

O GDB pode ajudar a investigar problemas no kernel, permitindo acompanhar a execução do código e analisar registradores e memória.

Make

O Make pode automatizar a compilação de diferentes partes do projeto.

8. Estrutura básica do sistema operacional

Um sistema operacional pode ser dividido em várias camadas.

Uma estrutura inicial poderia ser:

MEU SISTEMA OPERACIONAL
│
├── Bootloader
│
├── Kernel
│   ├── Gerenciamento de memória
│   ├── Processos
│   ├── Interrupções
│   └── Escalonador
│
├── Drivers
│   ├── Teclado
│   ├── Vídeo
│   ├── Disco
│   └── Rede
│
├── Sistema de arquivos
│
├── Shell
│
└── Interface gráfica

Essa organização permite desenvolver o projeto gradualmente.

9. Bootloader: o primeiro código executado

O bootloader é responsável por iniciar o processo de carregamento do sistema.

Simplificando:

BIOS/UEFI
     ↓
Bootloader
     ↓
Kernel
     ↓
Inicialização do hardware
     ↓
Sistema operacional

Em um projeto educacional, você pode começar criando um programa extremamente simples que inicialize e mostre uma mensagem na tela.

Por exemplo:

MEU SO
Inicializando...

Kernel carregado!

Parece simples, mas chegar até esse ponto já significa compreender uma parte importante do processo de inicialização de um computador.

10. Kernel: o coração do sistema

Depois do bootloader vem o kernel.

O kernel será responsável por tarefas fundamentais como:

  • gerenciamento de memória;
  • processos;
  • interrupções;
  • comunicação com hardware;
  • controle de dispositivos;
  • escalonamento;
  • segurança;
  • sistema de arquivos.

Uma combinação bastante utilizada em projetos educacionais é:

C + Assembly

O C facilita o desenvolvimento da maior parte do kernel, enquanto Assembly pode ser utilizado em determinadas operações específicas de baixo nível.

11. Criando o primeiro escalonador

Quando o sistema começa a executar várias tarefas, surge a necessidade de um scheduler, ou escalonador.

Uma estratégia simples para começar é o:

Round-robin

Imagine três tarefas:

Tarefa A
Tarefa B
Tarefa C

O sistema executa pequenos intervalos de cada uma:

A → B → C → A → B → C

Isso permite estudar os fundamentos da multitarefa.

Posteriormente, podem ser implementados algoritmos mais sofisticados.

12. Sistema de arquivos

Depois do kernel e dos processos, outro passo importante é criar suporte para armazenamento.

O sistema poderá evoluir para trabalhar com:

  • arquivos;
  • diretórios;
  • permissões;
  • dispositivos de armazenamento;
  • leitura e gravação.

No começo, entretanto, não é necessário criar um sistema de arquivos completamente novo.

Para fins educacionais, pode-se começar com uma estrutura extremamente simples e posteriormente estudar formatos existentes.

13. Interface gráfica

Depois que o sistema funcionar em modo texto, chega o momento de criar uma interface gráfica.

Uma possível evolução seria:

Terminal
   ↓
Modo gráfico
   ↓
Janelas
   ↓
Mouse
   ↓
Gerenciador de janelas
   ↓
Aplicativos

Para computadores antigos, uma interface minimalista pode fazer uma grande diferença no consumo de recursos.

14. Projetos Open Source para estudar

Você não precisa aprender tudo sozinho.

Existem projetos excelentes para estudar arquitetura de sistemas operacionais.

ReactOS

É um projeto de código aberto que busca implementar um sistema operacional compatível com a arquitetura e APIs do Windows.

É interessante para estudar compatibilidade, drivers e componentes de um sistema operacional de desktop.

xv6

O xv6 é um sistema operacional educacional baseado em conceitos do Unix e é amplamente utilizado para ensinar fundamentos de sistemas operacionais.

É especialmente interessante para quem quer entender:

  • processos;
  • memória;
  • chamadas de sistema;
  • arquivos;
  • interrupções.

Linux

O próprio kernel Linux é uma das maiores fontes de conhecimento disponíveis publicamente.

Entretanto, devido ao tamanho e à complexidade do projeto, ele não é necessariamente o melhor ponto de partida para quem está escrevendo o primeiro kernel.

15. Uma estratégia muito mais inteligente

Em vez de tentar criar tudo de uma vez, podemos estabelecer 100 etapas.

Por exemplo:

Fase 1 — Boot

  1. Bootloader
  2. Kernel
  3. Mensagem na tela
  4. Entrada pelo teclado
  5. Interrupções

Fase 2 — Kernel

  1. Gerenciamento de memória
  2. Heap
  3. Processos
  4. Scheduler
  5. Threads

Fase 3 — Hardware

  1. Teclado
  2. Mouse
  3. Vídeo
  4. Disco
  5. USB

Fase 4 — Sistema

  1. Sistema de arquivos
  2. Shell
  3. Usuários
  4. Permissões
  5. Aplicativos

Fase 5 — Interface

  1. Modo gráfico
  2. Janelas
  3. Mouse gráfico
  4. Menu
  5. Área de trabalho

E assim sucessivamente até chegar a uma versão muito mais completa.

16. O projeto pode ter dois objetivos

Uma ideia interessante seria criar um sistema operacional com duas versões.

MeuSO Lite

Voltado para computadores antigos.

Características:

  • baixo consumo de RAM;
  • interface simples;
  • inicialização rápida;
  • poucos serviços;
  • aplicativos básicos.

MeuSO Desktop

Voltado para computadores modernos.

Características:

  • interface gráfica;
  • multitarefa;
  • rede;
  • navegador;
  • gerenciamento de arquivos;
  • suporte a aplicações.

A mesma base poderia evoluir de maneira modular.

17. E o custo?

A parte mais interessante é que o desenvolvimento inicial pode praticamente não exigir investimento em hardware.

Você pode começar utilizando:

Recurso Custo inicial
Linux/Windows R$ 0, dependendo da licença
GCC Gratuito
QEMU Gratuito
GDB Gratuito
Binutils Gratuito
Git Gratuito
Editor de código Gratuito
Computador existente R$ 0
Hardware adicional Opcional

Ou seja, o maior investimento inicialmente será tempo de estudo e desenvolvimento.

18. É possível criar um SO para PC e celular?

Sim, mas é importante entender que portabilidade não significa que o mesmo código funcionará automaticamente em qualquer aparelho.

Uma arquitetura interessante seria:

                 MEU SO
                   │
              Kernel Core
                   │
       ┌───────────┼───────────┐
       │           │           │
      x86         ARM        RISC-V
       │           │           │
      PC       Dispositivo    Placa
               móvel/ARM

O núcleo do sistema poderia compartilhar componentes, enquanto cada arquitetura teria sua própria camada de hardware.

Esse conceito é chamado de portabilidade e é fundamental em projetos que pretendem funcionar em diferentes plataformas.

19. O melhor primeiro projeto

Se você está começando agora, não tente criar imediatamente um sistema com navegador, Wi-Fi, Bluetooth, aplicativos e interface gráfica.

Comece com:

Bootloader
    ↓
Kernel
    ↓
Tela
    ↓
Teclado
    ↓
Memória
    ↓
Processos
    ↓
Sistema de arquivos
    ↓
Shell
    ↓
Interface gráfica

Quando essa estrutura estiver funcionando, o projeto poderá crescer.

Conclusão

Criar um sistema operacional próprio é um dos melhores projetos para quem deseja compreender profundamente como os computadores funcionam.

Você aprenderá conceitos de:

  • programação em C;
  • Assembly;
  • arquitetura de computadores;
  • memória;
  • processadores;
  • processos;
  • threads;
  • drivers;
  • sistemas de arquivos;
  • redes;
  • segurança;
  • interfaces gráficas.

E o melhor: é possível começar praticamente sem gastar dinheiro, utilizando ferramentas gratuitas, QEMU e o computador que você já possui.

A estratégia mais eficiente não é tentar criar um "novo Windows" imediatamente. É construir uma pequena base funcional e evoluir o projeto passo a passo.

Um kernel que simplesmente inicializa e escreve "Meu SO iniciado!" já é o começo de um verdadeiro sistema operacional.

🚀 Próximo passo

Sim. Vamos montar a primeira versão real do MeuSO, começando pelo caminho mais simples: x86 32-bit + GRUB + kernel em C + Assembly + QEMU.

A ideia é chegar a:

PC
 ↓
GRUB
 ↓
Bootloader
 ↓
Kernel MeuSO
 ↓
Tela: "MEUSO iniciado!"
 ↓
QEMU

1. Estrutura do projeto

Crie esta estrutura:

meuso/
├── boot/
│   └── boot.s
├── kernel/
│   └── kernel.c
├── linker.ld
├── grub.cfg
└── Makefile

2. Criar as pastas

No Linux/Ubuntu/Debian:

mkdir -p meuso/boot
mkdir -p meuso/kernel

cd meuso

3. Bootloader — boot/boot.s

Crie:

nano boot/boot.s

Coloque:

.set ALIGN,    1<<0
.set MEMINFO,  1<<1
.set FLAGS,    ALIGN | MEMINFO
.set MAGIC,    0x1BADB002
.set CHECKSUM, -(MAGIC + FLAGS)

.section .multiboot

.align 4
.long MAGIC
.long FLAGS
.long CHECKSUM

.section .text

.global _start
.type _start, @function

_start:

    mov $stack_top, %esp

    call kernel_main

halt:

    cli
    hlt
    jmp halt


.section .bss

.align 16

stack_bottom:

.skip 16384

stack_top:

Esse código prepara uma pequena pilha e chama o nosso kernel.

4. Kernel — kernel/kernel.c

Agora:

nano kernel/kernel.c

Coloque:

#include <stdint.h>

void kernel_main(void)
{
    volatile uint16_t* video =
        (uint16_t*)0xB8000;

    const char* texto =
        "MEUSO iniciado com sucesso!";

    uint8_t cor = 0x0F;

    for (int i = 0; texto[i] != '\0'; i++)
    {
        video[i] =
            ((uint16_t)cor << 8) |
            texto[i];
    }

    while (1)
    {
        __asm__ volatile ("hlt");
    }
}

Aqui temos nosso primeiro kernel.

Ele escreve diretamente na memória de vídeo VGA.

5. Linker

Crie:

nano linker.ld

Use:

ENTRY(_start)

SECTIONS
{
    . = 1M;

    .text :
    {
        *(.multiboot)
        *(.text)
    }

    .rodata :
    {
        *(.rodata)
    }

    .data :
    {
        *(.data)
    }

    .bss :
    {
        *(COMMON)
        *(.bss)
    }
}

O linker informa como as diferentes partes do kernel devem ser organizadas na memória.

6. Configuração do GRUB

Crie:

mkdir -p iso/boot/grub
nano grub.cfg

Coloque:

menuentry "MeuSO" {
    multiboot /boot/meuso.bin
    boot
}

Agora copie:

cp grub.cfg iso/boot/grub/grub.cfg

7. Makefile

Crie:

nano Makefile

Use:

CC = i686-elf-gcc
AS = i686-elf-as
LD = i686-elf-gcc

CFLAGS = -m32 -ffreestanding -O2 -Wall -Wextra
LDFLAGS = -m32 -T linker.ld -ffreestanding -O2 -nostdlib

all: meuso.iso

boot.o:
	$(AS) boot/boot.s -o boot.o

kernel.o:
	$(CC) $(CFLAGS) -c kernel/kernel.c -o kernel.o

meuso.bin: boot.o kernel.o
	$(LD) $(LDFLAGS) -o meuso.bin boot.o kernel.o -lgcc

meuso.iso: meuso.bin
	mkdir -p iso/boot
	cp meuso.bin iso/boot/meuso.bin
	grub-mkrescue -o meuso.iso iso

run: meuso.iso
	qemu-system-i386 -cdrom meuso.iso

clean:
	rm -rf *.o *.bin *.iso iso/boot/meuso.bin

Importante: as linhas de comando do Makefile precisam começar com uma tabulação.

8. Instalar as ferramentas

Em Ubuntu/Debian:

sudo apt update

Depois:

sudo apt install build-essential qemu-system-x86 grub-pc-bin xorriso

Para compilar corretamente para x86 32-bit, também precisamos de um cross-compiler i686-elf-gcc.

Você pode verificar:

i686-elf-gcc --version

Se aparecer a versão do compilador, está pronto.

9. Compilar

Dentro da pasta:

cd meuso

Execute:

make

Se tudo estiver correto, será criado:

meuso.iso

A estrutura ficará aproximadamente:

meuso/
├── boot/
│   └── boot.s
├── kernel/
│   └── kernel.c
├── iso/
│   └── boot/
│       ├── grub/
│       │   └── grub.cfg
│       └── meuso.bin
├── boot.o
├── kernel.o
├── meuso.bin
├── meuso.iso
├── grub.cfg
├── linker.ld
└── Makefile

10. Executar no QEMU

Agora:

make run

O QEMU deverá abrir uma máquina virtual.

Você deverá ver:

MEUSO iniciado com sucesso!

🎉 Esse já é um sistema operacional inicializando de verdade.

11. Testar diretamente pelo QEMU

Também podemos executar:

qemu-system-i386 -cdrom meuso.iso

Para sair do QEMU:

Ctrl + Alt + G

e depois fechar a janela.

12. Próxima evolução do MeuSO

Agora começa a parte realmente interessante.

A versão 0.1 terá somente:

MeuSO 0.1
│
├── Bootloader
├── Kernel
└── Vídeo VGA

Podemos evoluir para:

MeuSO 0.2
├── Teclado
└── Shell

MeuSO 0.3
├── Gerenciamento de memória
└── Heap

MeuSO 0.4
├── Interrupções
└── Timer

MeuSO 0.5
├── Processos
└── Scheduler

MeuSO 0.6
├── Sistema de arquivos
└── HD

MeuSO 0.7
├── Mouse
└── Interface gráfica

MeuSO 0.8
├── Janelas
└── Desktop

MeuSO 0.9
├── Rede
└── Internet

MeuSO 1.0
├── Aplicativos
├── Interface gráfica
├── Arquivos
├── Rede
└── Segurança

Eu recomendo que o próximo passo seja o MeuSO 0.2: criar teclado + terminal (shell). Assim você poderá iniciar o sistema no QEMU e digitar comandos dentro do seu próprio sistema operacional, em vez de apenas mostrar uma mensagem na tela.