DEV Community: Marcos Oliveira

Meet This SSH Multi-Server Manager

Marcos Oliveira — Tue, 07 Jul 2026 13:33:03 +0000

If you manage multiple servers via SSH, you should check out LazySSH.

It's a terminal-based (TUI) SSH manager, inspired by tools like lazydocker and k9s, that makes it easy to navigate and manage entries in your ~/.ssh/config file.

Search by alias, IP, or tags
Pin favorite servers
Add, edit, and remove hosts directly from the interface
Ping to check availability
SSH connection with a single Enter
Sorting and filtering options
Preserves your ~/.ssh/config by creating automatic backups before making changes

Installation

Homebrew (macOS and Linux)

brew install lazyssh

Building with Go (Linux, macOS, and Windows)

If you already have Go installed:

git clone https://github.com/adembc/lazyssh.git
cd lazyssh
go build -o lazyssh ./cmd

Then, optionally, move the binary to a directory in your PATH:

sudo mv lazyssh /usr/local/bin/

Or install it directly using:

go install github.com/Adembc/lazyssh/cmd@latest

Usage

After installation, just run:

lazyssh

The program automatically reads the file:

~/.ssh/config

So all you need is to have your SSH hosts already configured as usual to start using it.

For more information, visit: https://github.com/adembc/lazyssh

Conheça esse Gerenciador para Múltiplos Servidores SSH

Marcos Oliveira — Tue, 07 Jul 2026 13:29:40 +0000

Se você gerencia vários servidores via SSH, vale conhecer o LazySSH.

É um gerenciador SSH em modo terminal (TUI), inspirado em ferramentas como lazydocker e k9s, que facilita a navegação e o gerenciamento das entradas do ~/.ssh/config.

Busca por alias, IP ou tags
Fixar servidores favoritos
Adicionar, editar e remover hosts pela interface
Ping para verificar disponibilidade
Conexão SSH com um único Enter
Ordenação e filtros
Preserva seu ~/.ssh/config, criando backups automáticos antes de alterações

Instalação

Homebrew (macOS e Linux)

brew install lazyssh

Compilando com Go (Linux, macOS e Windows)

Se você já tem o Go instalado:

git clone https://github.com/adembc/lazyssh.git
cd lazyssh
go build -o lazyssh ./cmd

Depois, opcionalmente, mova o binário para um diretório do PATH:

sudo mv lazyssh /usr/local/bin/

Ou instale diretamente com:

go install github.com/Adembc/lazyssh/cmd@latest

Utilizando

Após a instalação:

lazyssh

O programa lê automaticamente o arquivo:

~/.ssh/config

Portanto, basta ter seus hosts SSH configurados normalmente para começar a utilizá-lo.

Para mais informações acesse> https://github.com/adembc/lazyssh

Easily Create Progress Bars in C

Marcos Oliveira — Sat, 09 May 2026 21:57:38 +0000

c_progress_bar is a library for C that helps you create:

Colorful progress bar
Estimated remaining time
Elapsed time tracking
Works with MSVC, Clang, and GCC
Written in C99 with minimal dependencies

Installation

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

Simple example

#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;
}

For more information, visit the repository

Crie Facilmente Barras de Progresso em C

Marcos Oliveira — Sat, 09 May 2026 21:52:32 +0000

📊 Uma biblioteca simples de barras de progresso para C.

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: Build Your Own Desktop on Linux

Marcos Oliveira — Wed, 06 May 2026 12:44:35 +0000

Instead of relying on ready-made solutions (Waybar, Polybar, ...), you create your own.

Quickshell is a modern toolkit built with C++ for creating desktop interface components — bars, widgets, lock screens, launchers, and even complete environments — using QtQuick + QML.

It is not a "bar program".
It is also not a complete, ready-made desktop.

It is a foundation for building a custom desktop, running alongside a compositor like Hyprland, Sway, or i3.

In practice, it replaces several pieces:

status bar
notifications
widgets
lockscreen
display manager
system controls

Example

Quickshell uses:

QtQuick (UI)
QML (configuration/programming)
Hot reload (save → instant update) ([Quickshell][2])

Simple example (bar):

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

  implicitHeight: 30

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

Native integrations:

One of its strengths is that it comes already integrated with the system:

Wayland + X11 (windowing)
Hyprland, i3, Sway (workspaces)
PipeWire (audio)
BlueZ (Bluetooth)
UPower (battery)
MPRIS (media players)
standard system tray

This eliminates a lot of boilerplate.

Installation

Arch Linux / EndeavourOS / Manjaro

yay -S quickshell
### Or
paru -S quickshell

Or build from scratch on any system:

Dependencies:

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

Build:

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

Install:

sudo cmake --install build

Run:

quickshell

Configuration:

~/.config/quickshell/main.qml

Minimal example:

import QtQuick
import Quickshell

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

    Text {
        anchors.centerIn: parent
        text: "Quickshell is working"
    }
}

Works best on Wayland (Hyprland, Sway, etc.)
May be limited on X11
Still in development → bugs are normal
No config = blank screen

For more information, visit the repository.

Quickshell: construa seu próprio desktop no Linux

Marcos Oliveira — Wed, 06 May 2026 12:41:54 +0000

Em vez de depender de soluções prontas (Waybar, Polybar, ...), você cria o seu próprio.

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.

Quickshell: construa seu próprio desktop no Linux

Marcos Oliveira — Wed, 06 May 2026 12:27:59 +0000

Em vez de depender de soluções prontas (Waybar, Polybar, ...), você cria o seu próprio.

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

Marcos Oliveira — Wed, 06 May 2026 12:27:09 +0000

Monte layouts estilo IDE em JavaFX sem limitações e sem gambiarras.

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

Marcos Oliveira — Sun, 19 Apr 2026 21:39:38 +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

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.