Forem: Marcos Oliveira

Pyrite64, a Modern Engine for Nintendo 64

Marcos Oliveira — Mon, 13 Apr 2026 01:17:11 +0000

Pyrite64 is an open-source engine + visual editor for creating native 3D Nintendo 64 games — not "N64-style", but games that actually run on original hardware or accurate emulators. For development (scripting) with C++ or C

What's the idea?

Replace the old workflow (confusing SDKs + broken toolchains)
Bring something closer to Unity/Godot, but focused on the N64
Generate real ROMs compatible with the console

Features:

Visual editor with scene management
Model import (GLTF / Blender + Fast64)
Node graph (basic visual scripting)
Runtime engine (rendering, collision, audio, etc.)
HDR + bloom adapted for N64
Asset manager with automatic cleanup ([AlternativeTo][2])

Installation

Windows

The project itself automates almost everything.

Download the release (or clone the repo)
Run the editor
It automatically installs everything:

GNU/Linux

Dependencies:

GCC/Clang
CMake
Basic build libs
libdragon toolchain

Then just clone, compile, and install

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

Getting Started

Create a project

Inside the editor:

New Project
Set name + folder
It creates the structure with project.p64proj

Configure toolchain + emulator

File:

project.p64proj

Important fields:

"pathEmu": "ares",
"pathN64Inst": "/path/to/toolchain"

pathEmu → emulator command
pathN64Inst → toolchain root ([Instagit][3])

Import assets

Typical workflow:

Model in Blender
Export GLTF
Import into the editor

Build the scene

Add objects
Adjust transforms
Define materials

Game logic

Two options:

Node graph (visual)
C++ (more control)

Build and run

“Run” button
Generates ROM
Opens automatically in the emulator

For more information, visit the official website with FAQ.

Pyrite64, engine moderna para Nintendo 64

Marcos Oliveira — Mon, 13 Apr 2026 01:10:00 +0000

Apesar de ter Py de Python esse motor é para desenvolvimento(scripts) com C++ ou C.

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:

Install This Modern Network Scanner with TUI Mode

Marcos Oliveira — Wed, 25 Mar 2026 13:47:05 +0000

Built in Go, incredibly fast, and hassle-free.

If you've used tools like nmap and found them heavy, verbose, or too slow for simple tasks, Nibble solves exactly that problem.

Nibble is an open-source network scanner focused on simplicity, speed, and usability. It allows you to discover devices and services on your local network without needing to memorize complex commands or configure anything manually. It works on GNU/Linux, macOS, and Windows (x86 and ARM).

Installation

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

Or run it directly with:

npx @backendsystems/nibble

For more information, visit the repository.

Instale esse Scanner de Rede Moderno modo TUI

Marcos Oliveira — Wed, 25 Mar 2026 13:42:25 +0000

Feito em Go e muito rápido e sem dor de cabeça.

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

Marcos Oliveira — Wed, 25 Mar 2026 13:41:04 +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:

Gere Arte com Python (HSV Spiral)

Marcos Oliveira — Mon, 23 Mar 2026 15:13:51 +0000

A cada iteração, o ângulo muda e a cor avança no espectro HSV, criando esse efeito de espiral com gradiente arco-íris.

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

Aprenda Python

https://terminalroot.com.br/python

Manage APT packages with a modern terminal interface

Marcos Oliveira — Mon, 23 Mar 2026 14:15:37 +0000

Built with Go, works as a frontend for APT.

APTUI is a TUI (Terminal User Interface) written in Go that acts as a frontend for APT.

The concept is simple: do everything you already do with APT, but without leaving the screen and without typing repetitive commands.

Main features

Real-time filtering as you type
Fuzzy search (no need for exact name)
Fallback to apt-cache search

Installation

Via Go

go install github.com/mexirica/aptui@latest

Or via APT (Debian/Ubuntu)

(custom repository available in the project)

Then just run:

aptui

For more information, visit the repository.

Gerencie pacotes APT com interface moderna no terminal

Marcos Oliveira — Mon, 23 Mar 2026 14:12:06 +0000

Feito com Go que funciona como um frontend para o APT.

O APTUI é uma TUI (Terminal User Interface) escrita em Go que funciona como um frontend para o APT.

A proposta é simples: fazer tudo que você já faz com APT, mas sem sair da tela e sem ficar digitando comandos repetitivos.

Principais recursos

Filtro em tempo real enquanto você digita
Busca fuzzy (não precisa nome exato)
Fallback para apt-cache search

Instalação

Via Go

go install github.com/mexirica/aptui@latest

Ou via APT (Debian/Ubuntu)

(repositório próprio disponível no projeto)

Depois basta rodar:

aptui

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

Manage Your SQL Databases via Terminal with This App

Marcos Oliveira — Wed, 04 Mar 2026 11:56:49 +0000

For developers, DBAs, and analysts who need a lightweight, fast, and powerful tool for working with multiple databases in the terminal.

Pam is a minimalist command-line interface (CLI) tool written in Go, designed to simplify managing and executing SQL queries across multiple databases. Inspired by “The Office,” Pam pays homage to the character who organizes everything efficiently.

Key Features

Query Library: Save and organize your most-used SQL queries for easy access and reuse.
Multi-database Support: Compatible with PostgreSQL, MySQL, SQLite, Oracle, SQL Server, ClickHouse, and Firebird.
TUI (Terminal User Interface): Keyboard-focused navigation with Vim-inspired shortcuts for efficient manipulation of query results.
Direct Editing: Update cells, delete rows, and edit SQL directly in the results table.
Data Export: Export results in formats such as CSV, JSON, SQL, Markdown, or HTML.
Parameterized Queries: Support for parameterized queries, enabling dynamic searches without rewriting SQL.

Installation

You can install Pam via Go, by downloading the binary directly from the releases repository, or using Nix/NixOS.

go install github.com/eduardofuncao/pam/cmd/pam@latest

Basic Usage

After installation, initialize a connection to your desired database:

pam init mydb postgres "postgresql://user:pass@localhost:5432/mydb"

Add queries to your library:

pam add list_users "SELECT * FROM users"

And run them interactively:

pam run list_users

The TUI interface supports Vim-like shortcuts (j, k, h, l), copy cell (y), export data (x), edit cell (u), delete row (D), and more quick commands.

Pam stores its configuration in ~/.config/pam/config.yaml, allowing you to adjust row limits, column widths, and color schemes for the interface.

The app provides example commands for easily connecting to various database types, including PostgreSQL, MySQL, SQL Server, Oracle, SQLite, ClickHouse, and Firebird.

For more information, visit the repository

Gerencie suas bases SQL via Terminal com esse App

Marcos Oliveira — Wed, 04 Mar 2026 11:48:01 +0000

Para desenvolvedores, DBAs e analistas que precisam de uma ferramenta leve, rápida e poderosa para diferentes bancos de dados no terminal.

Pam é uma ferramenta de linha de comando (CLI) minimalista, escrita em Go, projetada para facilitar o gerenciamento e a execução de consultas SQL em múltiplos bancos de dados. Inspirada no universo de “The Office”, Pam homenageia a personagem que organiza tudo com eficiência.

Principais Destaques

Biblioteca de Queries: Salve e organize suas consultas SQL mais usadas, facilitando o acesso e reuso.
Multi-banco de dados: Compatível com PostgreSQL, MySQL, SQLite, Oracle, SQL Server, ClickHouse e Firebird.
Interface TUI (Terminal User Interface): Navegação focada no teclado, com atalhos inspirados no Vim, permitindo manipulação eficiente dos resultados das queries.
Edição Direta: Atualize células, exclua linhas e edite SQL diretamente na tabela de resultados.
Exportação de Dados: Exporte resultados em formatos como CSV, JSON, SQL, Markdown ou HTML.
Parâmetros em Queries: Suporte a consultas parametrizadas, facilitando buscas dinâmicas sem precisar reescrever SQL.

Instalação

Você pode instalar Pam via Go, baixando o binário diretamente do repositório de releases, ou usando Nix/NixOS.

go install github.com/eduardofuncao/pam/cmd/pam@latest

Uso Básico

Após instalar, basta inicializar uma conexão com o banco de dados desejado:

pam init mydb postgres "postgresql://user:pass@localhost:5432/mydb"

Adicione queries à sua biblioteca:

pam add list_users "SELECT * FROM users"

E execute-as de forma interativa:

pam run list_users

A interface TUI permite navegação com atalhos do tipo Vim (j, k, h, l), cópia de células (y), exportação de dados (x), edição de células (u), exclusão de linhas (D), entre outros comandos rápidos.

Pam armazena suas configurações em ~/.config/pam/config.yaml, permitindo ajustar limites de linhas, largura de colunas e esquemas de cores para a interface.

O aplicativo oferece exemplos de comandos para conectar-se facilmente a diversos tipos de bancos de dados, incluindo PostgreSQL, MySQL, SQL Server, Oracle, SQLite, ClickHouse e Firebird.

Para mais informações acesso o repositório

How to optimize the cd command to go back multiple folders at once

Marcos Oliveira — Fri, 20 Feb 2026 16:34:18 +0000

Spend less time counting how many folders you need to go back with this hack. 😃

Everyone in the UNIX/GNU world constantly uses the cd command to navigate into folders through the terminal.

The cd command, also known as chdir, is a command implemented in command-line interfaces of various operating systems (Unix or any Unix-like system, DOS, Windows, OS/2 and AmigaOS).

On GNU systems (used by most Linux distros) it is a shell builtin, meaning it's a bit more complicated to create a patch.

The cd command is very useful, however, one of the most annoying things is when you navigate into many folders and want to go back an exact number of steps, requiring commands like:

cd ../../../../../../
# Or
cd ..
cd ..
cd ..
cd ..
cd ..
cd ..

In both cases above, you need to go back 6 times.

But we can create a Bash function that reduces the amount of typing, making it faster and like a boss to go back to the 6th folder without much difficulty, like this: cd -6. Just add this function below to the end of your ~/.bashrc:

cd() {
    if [[ "$1" =~ ^-[0-9]+$ ]]; then
        local n=${1#-}
        local path=""
        for ((i=0; i<n; i++)); do
            path+="../"
        done
        builtin cd "$path"
    else
        builtin cd "$@"
    fi
}

Then reload your ~/.bashrc with the command: exec $SHELL or source ~/.bashrc and then just test it:

cd -6

In other words, use -(dash/minus) followed by the number of folders you want to go back, examples: cd -8, cd -7, cd -11,...

Remember that to go to your home folder, simply run: cd(without arguments) and to return to where you were, use: cd - without specifying any number!

Simple and practical, isn't it?!

Como otimizar o comando cd para voltar várias pastas de uma só vez

Marcos Oliveira — Fri, 20 Feb 2026 16:32:12 +0000

Perca menos tempo contando quantas pasta vc precisa voltar com esse hack. 😃

Todos do mundo UNIX/GNU usam constantemente o comando cd para entrar em pastas pelo terminal.

O comando cd, também conhecido por chdir, é um comando implementado em interfaces de linha de comandos de diversos sistemas operacionais (Unix ou qualquer um do tipo Unix, DOS, Windows, OS/2 e AmigaOS).

Nos sistemas GNU(usado pela maioria das distros Linux) ele é um shell builtin, ou seja, é um pouco mais complicado de fazer um patch.

O comando cd é muito útil, no entanto, uma das coisas mais chatas é quando você entra em muitas pastas e deseja voltar somente um quantidade exata e precisa rodar comando exemplo isso:

cd ../../../../../../
# Ou
cd ..
cd ..
cd ..
cd ..
cd ..
cd ..

Em ambos os casos acima, é necessário voltar 6 vezes.

Mas, podemos criar um função Bash que diminue essa quantidade de escrita para facilitar ir de forma mais rápida e like a boss para a 6º pasta atrás sem muita dificuldade, assim: cd -6, basta adicionar essa função abaixo ao final do seu ~/.bashrc:

cd() {
    if [[ "$1" =~ ^-[0-9]+$ ]]; then
        local n=${1#-}
        local path=""
        for ((i=0; i<n; i++)); do
            path+="../"
        done
        builtin cd "$path"
    else
        builtin cd "$@"
    fi
}

Depois releia o seu ~/.bashrc com o comando: exec $SHELL ou source ~/.bashrc e depois é só testar:

cd -6

Ou seja, use -(traço/menos) o número de pastas atrás que deseja, exemplos: cd -8, cd- 7, cd -11,...

Lembrando que para ir para a pasta pessoal basta rodar: cd(sem argumentos) e para retornar onde estava, use: cd - sem definir nenhum número!

Simples e prático, né?!