## 1. Project Overview & Quickstart (tonhowtf/omniget)

# OmniGet

> OmniGet is a free, open source desktop application for Windows, macOS and Linux that downloads online courses, video, audio, images, torrents and Telegram media, then transcribes, converts, reads and studies them. It is released under the GPL-3.0 license and built on yt-dlp.

OmniGet downloads paid online courses the user already owns (Hotmart, Udemy, Kiwify, Rocketseat), video and audio from YouTube, Instagram, TikTok, X/Twitter, Reddit, Twitch, Vimeo, Bilibili, Pinterest, Bluesky, Threads and Douyin, image galleries from 250+ sites through gallery-dl, torrents and magnet links, Telegram channels and groups, and roughly 1,800 further sites through yt-dlp. A browser extension for Chrome and Firefox sends pages and cookies to the app so logged-in content (Instagram stories, paid courses, members-only videos) downloads too.

Beyond downloading, the Tools section holds 158 single-purpose tools in 25 categories: YouTube (metadata, thumbnails, subtitles, comments, live chat, subtitle workshop, SponsorBlock, dislikes), Speech and subtitles (offline transcription with whisper.cpp, text to speech, subtitle translation, dubbing), Video editing (cut, convert, compress to a size, video to GIF, cut silence, subtitle convert and resync, restore, stabilize, sticker maker, screen recording), Audio (loudness normalization, noise removal), Instagram (24 tools: stories, highlights, unfollowers, ghost followers, analytics, giveaway picker, publish), X/Twitter (thread unroll, post to image, profile analytics, bookmarks export, archive reader, Grok), Facebook (album and video download), Reddit (post download, thread archive, data export reader), Pinterest (original-quality downloads, board and profile backup, AI-free search, duplicates, palettes), Twitch (emote packs, VOD chat export), Bilibili (danmaku export and burn-in), Spotify (Spicetify), Music (playlist to M3U, synced lyrics, Spotify history), LinkedIn (data export overview, connections, messages, profile score), Games (Switch album import, clip organizer, ProtonDB lookup), PDF (merge, split, compress, convert, OCR, repair, password, watermark and Bates numbering, crop margins, table of contents, redaction check, safe PDF, PDF to Markdown), Documents (SlideShare, Google Docs, Calameo, galleries), Images (upscale, resize, compress to a size, EXIF and GPS strip, duplicate photos, screenshot stitch, icon pack, spritesheet, OCR), System (cleanup, disk analyzer, hosts ad blocking, Windows privacy and hardening), Files (duplicates, bulk rename, secure delete, instant search, keep awake), Downloads (aria2, HLS/DASH manifests), Automation (auto clicker), Phone (KDE Connect), AI (price comparison, spending ledger, Ollama, humanize text, API key vault, MCP server with 37 tools) and CTF and analysis (hashes, file identification, classic ciphers, XOR, encodings, frequency analysis). A Claude Code plugin in claude-plugin/ fetches and transcribes media without the desktop app.

Plugins: Courses, Study (course player with timestamped notes, PDF/EPUB/CBZ reader, Markdown notes with a knowledge graph, Anki-compatible flashcards, focus timer, progress, local music library with synced lyrics), Telegram and Convert (FFmpeg with GPU acceleration). Also included: a League of Legends companion that reads the local game client (scouting, live stats, runes, profile editor, skin roulette, AI coach), on by default and switchable off; and OmniDisc, a self-hosted chat with end-to-end encrypted DMs, voice, video and screen sharing, off by default.

## Key facts

- Name: OmniGet
- Repository: https://github.com/tonhowtf/omniget
- License: GPL-3.0
- Platforms: Windows, macOS (Apple Silicon and Intel), Linux (x86_64 and ARM64)
- Cost: free, no account, no ads, no paid tier, no telemetry on what is downloaded
- Built with: Tauri 2, Rust, SvelteKit, SQLite
- Extraction engine: yt-dlp, bundled and self-updating, verified by SHA-256 before it runs; FFmpeg, aria2, gallery-dl and whisper.cpp are managed the same way
- Interface: graphical desktop app with a global hotkey (Ctrl+Shift+D), a command palette, 14 themes and 11 languages; no terminal, Python or manual setup required
- Command line: omniget-cli ships with every release
- Community: https://discord.gg/jgdxyPy7Vn

## Install

- Windows: `.exe` installer, portable `.exe` or `.msi` from Releases, or `winget install -e --id tonhowtf.OmniGet`
- macOS: `.dmg` from Releases or `brew install --cask tonhowtf/tap/omniget`. Unsigned, so first launch needs `xattr -cr /Applications/omniget.app`
- Linux: `.deb` for Debian and Ubuntu, `.rpm` for Fedora and openSUSE, `.AppImage` elsewhere. On Debian 12+ and Ubuntu 24.04+ the AppImage needs `sudo apt install libfuse2`
- Browser extension: exported from Settings → Plugins → Browser extension, or `omniget-chrome-extension-vX.Y.Z.zip` from Releases; loaded unpacked and paired with one click
- OmniGet is not published on Flathub.

## What it does not do

OmniGet downloads only what the user's own logged-in session can already open. It does not bypass DRM, break paywalls or share credentials. DRM-protected lectures are skipped and reported.

## 2. Official Technical Reference & Guides (tonhowtf/tonhowtf.github.io)

## File: README.md

# Astro Starter Kit: Minimal

```sh
npm create astro@latest -- --template minimal
```

> 🧑‍🚀 **Seasoned astronaut?** Delete this file. Have fun!

## 🚀 Project Structure

Inside of your Astro project, you'll see the following folders and files:

```text
/
├── public/
├── src/
│   └── pages/
│       └── index.astro
└── package.json
```

Astro looks for `.astro` or `.md` files in the `src/pages/` directory. Each page is exposed as a route based on its file name.

There's nothing special about `src/components/`, but that's where we like to put any Astro/React/Vue/Svelte/Preact components.

Any static assets, like images, can be placed in the `public/` directory.

## 🧞 Commands

All commands are run from the root of the project, from a terminal:

| Command                   | Action                                           |
| :------------------------ | :----------------------------------------------- |
| `npm install`             | Installs dependencies                            |
| `npm run dev`             | Starts local dev server at `localhost:4321`      |
| `npm run build`           | Build your production site to `./dist/`          |
| `npm run preview`         | Preview your build locally, before deploying     |
| `npm run astro ...`       | Run CLI commands like `astro add`, `astro check` |
| `npm run astro -- --help` | Get help using the Astro CLI                     |

## 👀 Want to learn more?

Feel free to check [our documentation](https://docs.astro.build) or jump into our [Discord server](https://astro.build/chat).

---

## File: src/content/blog/Post001.md

---
title: "Hostinger e configuração de um servidor de Minecraft do zero"
date: 2026-01-07
type: tutorial
label: Tutorial
image: images/minecraft01.png
---

## Introdução

A Hostinger facilita bastante isso. Eles te dão um domínio `.cloud` gratuitamente. Eu peguei o **audescire**, que vem de *aude scire*, que supostamente significa “ouse saber”. Não sei latim, estou confiando no Google Translate

Eles também te dão um IP fixo (pelo menos no plano que eu peguei). Com esse IP dá para fazer basicamente tudo usando subdomínios. O meu servidor de Minecraft, por exemplo, está rodando em:

```
minecraft.audescire.cloud
```

## Preparando a VPS

A máquina começa praticamente zerada. No máximo, você vai ter um editor de texto simples como o `nano`.

Antes de instalar qualquer coisa, é **muito importante atualizar o sistema**:

```bash
apt update && apt upgrade -y
```

Isso garante que:
- os pacotes estejam atualizados
- você evite erros estranhos durante instalações
- dependências antigas não quebrem o processo

Se você recebeu algum erro antes ou algo não instalou corretamente, rodar esse comando costuma resolver a maioria dos problemas.

## Instalando o Java

Para rodar Minecraft, você vai precisar de Java.  
Eu estou usando Java 21, mas **você não precisa usar exatamente a mesma versão**.

Se você escolheu uma VPS com Ubuntu:

```bash
apt install openjdk-21-jdk -y
```

Isso instala o **JDK** da OpenJDK na versão 21.

Para verificar se deu tudo certo:

```bash
java -version
```

Se aparecer a versão instalada, está tudo certo.


## Criando a pasta do servidor

Agora vamos organizar os arquivos do servidor.  
Eu gosto de usar `/opt` porque deixa as coisas mais organizadas.

```bash
cd /opt
mkdir minecraft
cd minecraft
```

Dentro dessa pasta ainda não temos nada.  


## Baixando o Fabric

Fora da VPS vá para:

```
https://fabricmc.net/use/server/
```

Escolha a versão do Minecraft que você quer usar.  
O próprio site já gera um comando pronto para você rodar no terminal.

No meu caso, eu baixei a versão **1.21.11**, então o site me indicou este comando:

```bash
curl -OJ https://meta.fabricmc.net/v2/versions/loader/1.21.11/0.18.4/1.1.1/server/jar
```

Esse comando **só baixa o arquivo `.jar`**.  
Nada mais, nada menos (eu acho).

Se algo der errado depois, vale conferir se o nome do arquivo baixado bate exatamente com o que você está tentando executar.

## Criando o script de inicialização

Vamos criar um script para iniciar o servidor.

```bash
touch start.sh
nano start.sh
```

O site, pelo menos na minha época, te indica configurar desse jeito:

```bash
java -Xmx2G -jar fabric-server-mc.1.21.11-loader.0.18.4-launcher.1.1.1.jar nogui
```

Agora, destrinchando o comando:

- `-Xmx2G`  
  Define o **uso máximo de RAM**. Nesse exemplo, 2 GB.

- `fabric-server-...jar`  
  É o arquivo que você acabou de baixar.  
  Se der erro, confira se o nome está correto.

- `nogui`  
  Inicia o servidor sem interface gráfica, o que é ideal para VPS.


### A configuração que eu usei

Eu usei uma configuração um pouco diferente:

```bash
java -Xms4G -Xmx8G -jar fabric-server-mc.1.21.11-loader.0.18.4-launcher.1.1.1.jar nogui
```

Aqui entra mais um detalhe importante:

- `-Xms4G`  
  Define a **memória mínima** que o servidor vai usar.

- `-Xmx8G`  
  Define a **memória máxima**.

Ou seja: estou dizendo que o servidor pode usar **entre 4 GB e 8 GB de RAM**.

Já vi muita gente usando:

```bash
-Xms8G -Xmx8G
```

Ou seja, mínimo e máximo iguais.  
Não sei dizer exatamente o ganho real disso, mas fica a seu critério.


## Dando permissão e iniciando o servidor

Agora precisamos dar permissão de execução ao script:

```bash
chmod +x start.sh
```

Se você estiver se sentindo mais caótico, pode usar:

```bash
chmod 777 start.sh
```

Execute o servidor:

```bash
./start.sh
```

Isso vai:
- iniciar o servidor
- criar todas as pastas necessárias
- gerar o arquivo `eula.txt`

## Aceitando o EULA

Abra o arquivo:

```bash
nano eula.txt
```

Procure por:

```txt
eula=false
```

Troque para:

```txt
eula=true
```

Salve com:
- `Ctrl + X`
- `Enter`
- `Enter`


Se essa for sua primeira vez usando um editor no terminal, pode parecer estranho.  
Relaxa. Let it rip, lembre de ousar e logo vai se tornar automático.

Depois disso, você já tem **um servidor funcional**.

## Configurações extras

Algumas coisas que você pode querer fazer depois:

### Permitir jogadores piratas
Edite o arquivo `server.properties` e altere:

```txt
online-mode=false
```

### Instalar mods Fabric
Essa instalação funciona da mesma forma para todos os mods:
- baixe o mod
- coloque na pasta `mods/`
- reinicie o servidor


## Configurando o domínio na Hostinger

Se você comprou hospedagem da Hostinger, o domínio `.cloud` vem de graça e é bem simples de usar.

No painel da Hostinger:
1. Página inicial
2. **Domínios**
3. **Meus domínios**
4. **Gerenciar**
5. **DNS / Nameservers**
6. **Gerenciar registros DNS**

Vamos criar um registro do tipo **A**:

```txt
Tipo: A
Nome: minecraft
Aponta para: IP da sua VPS
TTL: 14400
```

Algumas observações:
- `A` vem de *Address*
- `Aponta` é o mesmo ip que aparece na sua vps
- `TTL` tempo de vida do seu dns em cache. Deixe o padrão
- `Nome` é como vai ficar o seu subdomínio

No meu caso, ficou:

```
minecraft.audescire.cloud
```

Você pode escolher outro nome sem ser minecfrat.

Depois de salvar, em poucos minutos você já consegue se conectar usando o domínio.

---

## File: src/content/blog/Post002.md

---
title: "Node.js"
date: 2026-01-20
type: bobajada
label: Bobajada
image: images/Nekoo.jpg
---

## Node.js

Node.js é uma plataforma que permite executar JavaScript fora do navegador. Originalmente o JavaScript foi criado para rodar apenas no browser, mas lá para 2008 o Google lançou o V8, um motor JavaScript OpenSource. Em 2009, Ryan Dahl utilizou o V8 para criar o Node.js, possibilitando assim que o JavaScript fosse executado no servidor.

## Call Stack

A Call Stack é uma estrutura de dados que controla a ordem de execução das funções no JavaScript. Sempre que uma função é chamada, ela é adicionada na Call Stack. Quando termina sua execução, ela é removida. A Call Stack é um LIFO (Last In, First Out). O último que entra é o primeiro a sair.

### Exemplo de código

```javascript
function buga() {
  return "buga";
}

function bugaBuga(cycles) {
  return buga().repeat(cycles);
}

function printBuga(message) {
  const result = message + " " + bugaBuga(3);
  console.log(result);
}

printBuga("Morcego");
```

## Como o JavaScript executa?

**Hoisting**

Antes de executar qualquer código, o JavaScript "iça" (hoisting) todas as declarações de funções para o topo do escopo. 

1. `buga()` é declarada e armazenada na memória
2. `bugaBuga()` é declarada e armazenada na memória
3. `printBuga()` é declarada e armazenada na memória

**Execução**

Após o hoisting, o JavaScript executa o código de cima para baixo:

### Ordem na Call Stack

1. `printBuga("Morcego")` entra na stack
2. Dentro de printBuga, `bugaBuga(3)` é chamado e entra na stack
3. Dentro de bugaBuga, `buga()` é chamado e entra na stack
4. `buga()` retorna "buga" e **sai da stack**
5. `bugaBuga(3)` completa (retorna "bugabugabuga") e **sai da stack**
6. `printBuga()` executa o console.log e completa, então **sai da stack**

**Resultando em**

 `Morcego bugabugabuga`

## Single Thread

O Node.js é **single-threaded**, ou seja, possui apenas uma Call Stack. Isso significa que ele só pode executar uma tarefa por vez na thread principal.

### Mas então, como o JavaScript consegue executar código assíncrono?

## libuv

A **libuv** é uma biblioteca em C que implementa o **Thread Pool** e o **Event Loop** no Node.js. Ela é responsável por delegar operações assíncronas, permitindo que o JavaScript continue executando sem travar.

```javascript
const fs = require('fs');

console.log("start")

fs.readFile('./test.txt', 'utf-8', function callback(_, data) {
    console.log(data);
});

console.log("end")
```

## Como o Node.js lida com operações bloqueantes?

O `fs.readFile()` é uma operação **bloqueante** ela leva tempo para ser executada. Se não tivéssemos a libuv, nosso programa ficaria **travado** esperando a leitura terminar antes de continuar a execução.

### Mas então, como o Node.js resolve isso?

1. **Thread Pool** 
   1. `fs.readFile()` é removido da Call Stack
   2. A libuv delega a tarefa para uma thread do Thread Pool
   3. A Call Stack fica livre para continuar executando outras tarefas

2. **Processamento em background**
   1. Enquanto a Call Stack continua executando o código, a thread do Thread Pool trabalha lendo o arquivo
   2. Quando a leitura termina, a função já processada com todo o texto vai para a **Callback Queue**
3. **Callback Queue**
   1. Ele fica na fila esperando o Event Loop
4. **Event Loop**
   1. O **Event Loop** monitora a Callback Queue e a Call Stack
   2. Quando detecta que a Call Stack fica vazia, ele pega o primeiro callback da fila, se tiver.
   3. O callback é movido para a Call Stack e finalmente executado