Terminal Root

Crie Facilmente Barras de Progresso em C

Sat, 09 May 2026 18:50:27 +0000

c_progress_bar é uma biblioteca para C que ajuda a você criar:

Barra de progresso colorida
Estimativa de tempo restante
Rastreamento de tempo decorrido
Trabalha com MSVC, Clang e GCC
Escrito em C99 com dependências mínimas

Instalação

git clone https://github.com/c-modules/c_progress_bar
cd c_progress_bar/
cmake . -B build
cmake --build build/
sudo cmake install build

Simples exemplo

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#include "c_progress_bar.h"

#define N 1000000000

int main(void)
{
    double sum = 0.0;

    // Setup progress bar
    CPB_Config config = cpb_get_default_config();
    config.description = "Processing";                // Default: ""
    config.min_refresh_time = 0.1;                    // Minimum refresh time in seconds. Default: 0.1.
    config.timer_remaining_time_recent_weight = 0.3;  // Weight for recent rate in remaining time estimation. Range: [0, 1]. Default: 0.3.

    // You don't need to modify anything for CPB_ProgressBar.
    // Just call cpb_init
    CPB_ProgressBar progress_bar;
    cpb_init(&progress_bar, 0, N, config);

    // Main loop
    cpb_start(&progress_bar);
    for (int64_t i = 0; i <= N; i++)
    {
        if (i % 1000 == 0)
        {
            cpb_update(&progress_bar, i);
        }

        sum += (i % 100) * 0.0001;
    }
    cpb_finish(&progress_bar);

    printf("Final result: %f\n", sum);

    return 0;
}

Para mais informações acesse o repositório

Quickshell: construa seu próprio desktop no Linux

Wed, 06 May 2026 09:23:06 +0000

O Quickshell é um toolkit moderno feito com C++ para criar componentes de interface de desktop — barras, widgets, lock screens, launchers e até ambientes completos — usando QtQuick + QML.

Não é um “programa de barra”.
Também não é um desktop completo pronto.

É uma base para construir um desktop customizado, rodando junto com um compositor como Hyprland, Sway ou i3.

Na prática, ele substitui várias peças:

barra (status bar)
notificações
widgets
lockscreen
display manager
controles de sistema

Exemplo

O Quickshell usa:

QtQuick (UI)
QML (configuração/programação)
Hot reload (salvou → atualizou na hora) ([Quickshell][2])

Exemplo simples (barra):

PanelWindow {
  anchors {
    top: true
    left: true
    right: true
  }

  implicitHeight: 30

  Text {
    anchors.centerIn: parent
    text: "hello world"
  }
}

Integrações nativas:

Um dos pontos fortes é já vir integrado com o sistema:

Wayland + X11 (windowing)
Hyprland, i3, Sway (workspaces)
PipeWire (áudio)
BlueZ (Bluetooth)
UPower (bateria)
MPRIS (players de mídia)
system tray padrão

Isso elimina muito boilerplate.

Instalação

Arch Linux / EndeavourOS / Manjaro

yay -S quickshell
### Ou
paru -S quickshell

Ou construa do zero em qualquer sistema:

Dependências:

sudo apt install cmake ninja-build qt6-base-dev qt6-declarative-dev \
qt6-wayland wayland-protocols libpipewire-0.3-dev \
libdbus-1-dev libxkbcommon-dev

Clone:

git clone https://github.com/quickshell-mirror/quickshell.git
cd quickshell

Construa:

cmake -B build -G Ninja
cmake --build build

Instale:

sudo cmake --install build

Rode:

quickshell

Configuração:

~/.config/quickshell/main.qml

Exemplo mínimo:

import QtQuick
import Quickshell

PanelWindow {
    anchors.top: true
    anchors.left: true
    anchors.right: true
    implicitHeight: 30

    Text {
        anchors.centerIn: parent
        text: "Quickshell funcionando"
    }
}

Funciona melhor em Wayland (Hyprland, Sway, etc.)
Em X11 pode ser limitado
Ainda está em desenvolvimento → bugs são normais
Sem config = tela vazia

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

Conheça esse docking moderno para JavaFX

Wed, 06 May 2026 08:57:15 +0000

O SnapFX é um framework de docking para JavaFX, focado em criar interfaces flexíveis no estilo:

IntelliJ / VS Code
IDEs em geral
ferramentas com múltiplos painéis

Leve e moderno, pensado para layouts dinâmicos e organizados, sem você ter que reinventar drag & drop de janelas.

Instalação

Via Gradle

implementation("org.snapfx:snapfx-core:<version>")

Construa:

git clone https://github.com/Beowolve/SnapFX.git
./gradlew publishToMavenLocal

Exemplo Simples:

import org.snapfx.SnapFX;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.TextArea;
import javafx.stage.Stage;

public class SimpleDemo extends Application {
    @Override
    public void start(Stage stage) {
        SnapFX snapFX = new SnapFX();

        // Dock nodes
        snapFX.dock(new TextArea("Editor 1"), "Editor");
        snapFX.dock(new TextArea("Console"), "Console");

        // Build layout
        Scene scene = new Scene(snapFX.buildLayout(), 800, 600);

        stage.setScene(scene);
        snapFX.initialize(stage);
        // Optional: switch theme at runtime via named catalog entry
        // snapFX.setThemeStylesheet(SnapFX.getAvailableThemeStylesheets().get("Dark"));
        stage.show();
    }
}

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

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.