Terminal Root

Adicionei um Jogo ao Sistema Operacional Que Eu Criei

Sun, 19 Apr 2026 18:18:32 +0000

☕ Nesse vídeo mostrei como desenvolvi um jogo baremetal em um projeto de de sistema operacional para jogos de terminal que estou desenvolvendo com C++ e GNU Assembler.

Esse vídeo é continuação desse vídeo e esse é o repositório do projeto.

Assista ao Vídeo

Aprenda:

👑 Aprenda a criar sua própria linguagem de programação: https://terminalroot.com.br/mylang
✅ Aprenda Criação de Games com C++ e SFML: https://terminalroot.com.br/games
✅ Pacote Promocional C++: https://terminalroot.com.br/promo
✅ Aprenda C++ e Qt: https://terminalroot.com.br/cpp
✅ Conheça nossos Cursos: https://bit.ly/CursosTerminalRoot
🎁 Todos os Cursos na Udemy: https://bit.ly/UdemyTerminalRoot

Faça roteamento de Tráfego de aplicações via linha de comando

Wed, 15 Apr 2026 22:00:27 +0000

O toricli.sh é uma ferramenta escrita em Go, focado em facilitar o roteamento de tráfego de aplicações via linha de comando. A proposta é simplificar o uso de anonimização no Linux sem depender de configurações complexas.

Ele entra na mesma categoria de ferramentas como torsocks, mas com uma abordagem mais direta e automatizada.

Instalação

Para Windows use o WSL

# systemd
curl -fsSL https://raw.githubusercontent.com/thobiasn/tori-cli/main/deploy/install.sh | sudo sh

# Arch
yay -S tori-cli-bin

# macOS
curl -fsSL https://raw.githubusercontent.com/thobiasn/tori-cli/main/deploy/install.sh | sh -s -- --client

Docker:

docker run -d --name tori \
  --restart unless-stopped \
  --pid host \
  -v /var/run/docker.sock:/var/run/docker.sock:ro \
  -v /proc:/host/proc:ro \
  -v /sys:/host/sys:ro \
  -v /run/tori:/run/tori \
  -v tori-data:/var/lib/tori \
  -v ./config.toml:/etc/tori/config.toml:ro \
  ghcr.io/thobiasn/tori-cli:latest

Exemplo de uso

toricli curl example.com

E o tráfego sai anonimizado.

Para mais informações acesse: https://toricli.sh/.

Pyrite64, engine moderna para Nintendo 64

Sun, 12 Apr 2026 22:06:32 +0000

Pyrite64 é uma engine + editor visual open source para criar jogos 3D nativos de Nintendo 64 — não “estilo N64”, mas que rodam de verdade no hardware original ou em emuladores precisos. Para desenvolvimento(scripts) com C++ ou C

Qual a ideia?

Substituir o workflow antigo (SDKs confusos + toolchains quebradas)
Trazer algo mais próximo de Unity/Godot, mas focado no N64
Gerar ROMs reais compatíveis com o console

Com:

Editor visual com gerenciamento de cenas
Import de modelos (GLTF / Blender + Fast64)
Node graph (script visual básico)
Engine runtime (render, colisão, áudio, etc.)
HDR + bloom adaptado ao N64
Asset manager com limpeza automática ([AlternativeTo][2])

Instalação

Windows

O próprio projeto automatiza quase tudo.

Baixe o release (ou clone o repo)
Execute o editor
Ele instala automaticamente:

GNU/Linux

Dependências:

GCC/Clang
CMake
libs básicas de build
toolchain do libdragon

Depois é só clonar, compilar e instalar

git clone https://github.com/HailToDodongo/pyrite64
cd pyrite64
mkdir build && cd build
cmake ..
make
sudo make install

Primeiros passos

Criar projeto

Dentro do editor:

New Project
Define nome + pasta
Ele cria estrutura com project.p64proj

Configurar toolchain + emulador

Arquivo:

project.p64proj

Campos importantes:

"pathEmu": "ares",
"pathN64Inst": "/caminho/toolchain"

pathEmu → comando do emulador
pathN64Inst → raiz da toolchain ([Instagit][3])

Importar assets

Fluxo típico:

Modela no Blender
Exporta GLTF
Importa no editor

Montar cena

Adiciona objetos
Ajusta transform
Define materiais

Lógica do jogo

Duas opções:

Node graph (visual)
C++ (mais controle)

Build e rodar

Botão “Run”
Gera ROM
Abre no emulador automaticamente

Para mais informações acesse o site oficial com FAQ.

Veja também:

Visualize Áudio com Python

Wed, 08 Apr 2026 11:36:22 +0000

O Librosa é uma biblioteca Python focada em análise e processamento de áudio e música.

Uma lib construída sobre NumPy/SciPy para trabalhar com sinais de áudio no domínio do tempo e da frequência. Muito usada em IA, DSP e projetos musicais.

Instalação (Python)

pip install librosa matplotlib

Se der erro com áudio:

pip install soundfile

Em distros GNU/Linux é necessário antes criar um ambiente virtual pra usar o PIP

python -m venv venv
source venv/bin/activate

Exemplo de uso

main.py

import librosa
import librosa.display
import matplotlib.pyplot as plt

y, sr = librosa.load(librosa.example('trumpet'))
plt.figure(figsize=(10, 4))
librosa.display.waveshow(y, sr=sr)
plt.title("Waveform of Sample Audio")
plt.show()

Execute o código:

python main.py

Para mais informações acesse o site oficial da Librosa.

Aprenda Python do Zero

https://terminalroot.com.br/python

TermMark: Markdown direto no terminal, sem dependências

Tue, 07 Apr 2026 19:13:05 +0000

O TermMark é um Markdown viewer para terminal, focado em simplicidade e performance. Ele renderiza arquivos .md com formatação legível — sem precisar de browser, Electron ou libs pesadas.

Zero dependências
Extremamente leve (C++)
Interface baseada em terminal (TUI simples)

Instalação

git clone https://github.com/ishanawal/TermMark.git
cd TermMark
mkdir build && cd build
cmake ..
make
sudo install -v termmark /usr/local/bin/

Para utilizar consulte o help rápido:

termmark --help

Para mais informações acesse o repositório: https://github.com/ishanawal/TermMark.

Gere Circuitos Lógicos com Python

Wed, 25 Mar 2026 10:56:19 +0000

Dependências

Windows, instale o PIP e depois instale o Schemdraw com o PIP:

pip install schemdraw

Em GNU, Linux e UNIX, crie um ambiente virtual e instale com o PIP:

mkdir -p ~/.local/bin
python -m venv ~/.local/bin/venv
. ~/.local/bin/venv/bin/activate
pip install schemdraw

Código Python:

import schemdraw
import schemdraw.logic as logic

with schemdraw.Drawing() as d:
    d += logic.And(inputs=2).color('blue')
    d += logic.Or().right().color('green')
    d += logic.Not().right().color('red')
    d.draw()

Aprenda Python

https://terminalroot.com.br/python

Instale esse Scanner de Rede Moderno modo TUI

Wed, 25 Mar 2026 10:37:46 +0000

Se você já usou ferramentas como nmap e achou pesado, verboso ou lento demais para tarefas simples, o Nibble resolve exatamente esse problema.

Nibble é um scanner de rede open-source focado em simplicidade, velocidade e usabilidade. Ele permite descobrir dispositivos e serviços na sua rede local sem precisar decorar comandos complexos ou configurar nada manualmente.Funciona em GNU/Linux, macOS e Windows (x86 e ARM).

Instalação

brew install backendsystems/tap/nibble
pipx install nibble-cli
npm install -g @backendsystems/nibble
go install github.com/backendsystems/nibble@latest

Ou rodar direto com:

npx @backendsystems/nibble

Para mais informações acesse o repositório.

Os 10 Melhores Monitores para Programadores

Wed, 25 Mar 2026 10:09:59 +0000

Esses monitores são ótimos para programadores, oferecendo desde alta resolução e precisão de cores até design ergonômico para longas sessões de codificação. O tamanho, a qualidade da tela e a ergonomia são aspectos cruciais que podem melhorar significativamente a experiência de programação.

01. Dell UltraSharp P2725H

O P2725H oferece uma tela 4K de 27 polegadas, com ótima precisão de cores, ideal para programadores que precisam de clareza em detalhes.
Resolução: 3840 x 2160 (4K)
Características: IPS, excelente cobertura de cores (95% DCI-P3), portas USB-C com carregamento.
Ideal para: programadores que trabalham com gráficos, design ou precisam de uma tela com resolução muito alta.

Clique aqui para adquirir esse Monitor

02. LG 4wn80c-b ultrawide

O 4wn80c-b é um monitor ultrawide de 34 polegadas com resolução 1440p que oferece uma ótima experiência multitarefa.
Resolução: 3440 x 1440 (UltraWide)
Características: Painel IPS, design curvado, excelente para produtividade, ajuste de altura e inclinação.
Ideal para: programadores que fazem multitasking e precisam de mais espaço na tela para abrir várias janelas ou códigos simultaneamente.

Clique aqui para adquirir esse Monitor

03. ASUS ProArt PA278QV

Focado em precisão de cores, o PA278QV é perfeito para programadores que também trabalham com design ou edição gráfica.
Resolução: 2560 x 1440 (QHD)
Características: Calibração de cores de fábrica, painel IPS, suporte ergonômico (ajuste de altura, inclinação, rotação).
Ideal para: programadores que precisam de um monitor preciso para edição de imagens ou desenvolvimento de interfaces.

Clique aqui para adquirir esse Monitor

04. BenQ PD2705U

O PD2705U é um monitor 4K de 27 polegadas com excelente performance para programadores que necessitam de uma tela grande e com excelente precisão de cores.
Resolução: 3840 x 2160 (4K)
Características: Painel IPS, design ergonômico, modos de exibição especializados para programadores (como o modo de leitura).
Ideal para: programadores que precisam de alta resolução para multitarefas e atividades de design.

Clique aqui para adquirir esse Monitor

05. Samsung Odyssey AI TV 55” OLED 4K S85F

O Odyssey AI TV 55” OLED 4K S85F ** é um monitor **curvo de 55 polegadas, ideal para programadores que preferem um monitor mais imersivo e com excelente taxa de atualização.
Resolução: 3840 x 2160 (4K)
Características: Curvatura de 1000R, taxa de atualização de 240Hz, tempo de resposta rápido, painel VA.
Ideal para: programadores que também são gamers ou preferem uma tela curva para uma melhor experiência de trabalho imersivo.

Clique aqui para adquirir esse Monitor

06. Acer Predator X34

O X34 é um monitor ultrawide curvo de 34 polegadas, excelente para programadores que trabalham com múltiplos projetos ou janelas.
Resolução: 3440 x 1440 (UltraWide)
Características: Curvatura 1900R, taxa de atualização de 100Hz, painel IPS, suporte G-Sync.
Ideal para: programadores que buscam um monitor de alta qualidade com um campo de visão amplo para multitarefas.

Clique aqui para adquirir esse Monitor

07. Dell P2719H

O P2719H é um monitor de 27 polegadas com uma ótima relação custo-benefício, ideal para programadores que buscam um display de qualidade sem gastar muito.
Resolução: 1920 x 1080 (Full HD)
Características: Painel IPS, borda fina, design ajustável em altura, rotação e inclinação.
Ideal para: programadores que precisam de um monitor confiável e confortável para trabalhar longas horas.

Clique aqui para adquirir esse Monitor

08. Philips 276E8VJSB

Valor: R$ 750,00
O 276E8VJSB é um monitor 4K de 27 polegadas com uma ótima relação de custo-benefício, ideal para quem quer alta resolução sem gastar tanto.
Resolução: 3840 x 2160 (4K)
Características: Painel IPS, excelente desempenho em cores e contrastes.
Ideal para: programadores que querem um monitor com excelente resolução e boa qualidade de imagem para tarefas diárias e leitura de código.

Clique aqui para adquirir esse Monitor

09. LG UltraGear 27GN750-27

O LG 27UK850-W é um monitor 4K de 27 polegadas com ótima precisão de cores, sendo uma excelente escolha para programadores e profissionais criativos.
Resolução: 3840 x 2160 (4K)
Características: Conexões USB-C, painel IPS, suporte HDR10.
Ideal para: programadores que buscam um monitor com boa qualidade de imagem e conexão USB-C para facilitar a configuração.

Clique aqui para adquirir esse Monitor

10. VIVO Monitor Ultrawide + suporte para laptop

O VIVO Monitor Ultrawide + suporte para laptop é um monitor 4K de 49 polegadas que combina design minimalista com excelente precisão de cores, ideal para programadores e designers gráficos.
Resolução: 3840 x 2160 (4K)
Características: Painel IPS, ajustes ergonômicos (altura, rotação, inclinação), baixo consumo de energia.
Ideal para: programadores que buscam um monitor altamente preciso e ergonômico para trabalho prolongado.

Clique aqui para adquirir esse Monitor

Veja também:

Baixe vídeos do Youtube com esse App TUI

Tue, 24 Mar 2026 10:08:52 +0000

xytz é um projeto open source simples e muito útil pra quem curte terminal que é um frontend TUI pro yt-dlp feito em Go usando Bubble Tea.

Busca vídeos do YouTube direto no terminal
Navegação por canal (/channel) e playlist (/playlist)
Escolha de qualidade/formatos antes de baixar
Download com progresso, velocidade e ETA
Resume de downloads interrompidos
Histórico de buscas
Atalhos estilo Vim
Playback direto via mpv (sem baixar) ([pkg.go.dev][1])

Instalação

Via Go:

go install github.com/xdagiz/xytz@latest

Via cURL

curl -fsSL https://raw.githubusercontent.com/xdagiz/xytz/main/install.sh | bash

Homebrew (macOS)

brew install xdagiz/tap/xytz

Arch

paru -S xytz-bin # or yay -S xytz-bin

Scoop (Windows)

scoop bucket add xdagiz https://github.com/xdagiz/scoop-bucket.git
scoop install xdagiz/xytz

Após instalar basta rodar:

xytz

E um guia rápido em:

xytz --help

Para mais informações acesse o repositório.

Gere Arte com Python (HSV Spiral)

Mon, 23 Mar 2026 12:09:11 +0000

Usando turtle e colorsys para gerar um padrão geométrico colorido.

Dependências

No Windows com WinGet:

winget install -e --id CarlWenrich.PythonTkGuiBuilder

Em distros GNU/Linux com APT:

sudo apt install python3-tk

Código Python

main.py

import colorsys
import turtle

t = turtle.Turtle()
s = turtle.Screen()

s.bgcolor('black')
t.speed(0)

n = 36
h = 0

for i in range(460):

    c = colorsys.hsv_to_rgb(h, 1, 0.8)
    h += 1/n
    t.color(c)
    t.left(145)

    for j in range(5):
        t.forward(300)
        t.left(150)

Depois basta rodar:

python main.py