Final Version REDC2
Works on Linux, MacOS and Windows without problems.

Information about this project:
REDC2 is a terminal-based tool that allows you to control and monitor multiple systems from a single window using SSH (Secure Shell).
I built REDC2 in Python because of its simplicity and because this project does not require low-level programming.
I personally run a homelab with two devices: an old laptop and a Raspberry Pi. I always disliked having multiple terminal windows open just to manage my systems, so I created REDC2 to bring everything together in one interface.
When you run main.py, REDC2 displays your configured devices in a simple terminal dashboard. The devices are configured through .toml files, and the dashboard displays information such as CPU usage, RAM usage, and system status.
You can customize the terminal interface using Ctrl + P to open the command palette. Switching between devices is also simple: press the Escape key to move between systems.
The goal of REDC2 is to make managing a small homelab faster, cleaner, and more convenient without needing multiple terminal windows.

Fixing MacOS compatability Issues

Spent an hour cleaning the code and the filesystem.
So easy to read now

LME My own Compiler Devlog #5

Finished the first real end-to-end version of Luna today.

Wrote generation.h - takes the parse tree from the parser and walks it to spit out x86-64 NASM assembly. Right now it just handles the one node type I have (NodeExit) and generates the mov/syscall pair for exiting with a given code.

Rewired main.cpp so it actually uses the tokenizer -> parser -> generator pipeline properly instead of skipping straight from tokens to asm like before. Cleaner flow now:

source -> tokens -> parse tree -> asm -> nasm -> ld -> binary

Tested it with:
cik 42;

Compiled clean, ran the output binary, echo $? gave 42. First time the whole pipeline worked end to end without me hand-patching anything.

Also wrote a proper README and a .gitignore so I can actually put this on GitHub without dumping build folders and .idea junk into the repo.

Still only supports one statement (cik ;), no variables or math yet. Next up: probably adding a second statement type so the parser/generator actually have to branch on something.

DEVLOG #5 Updated the parts where i used AI,
The final project has no AI involved rn :)

REDC2 lets you access your devices/machines through SSH using Python.
It gives you the ability to switch between machines easily and gives you basic infos about your configured machines.
I use this everyday messing with my homelab

Turned into exe and created a machines.toml.example file ready to ship

DEVLOG #4
Took me allot to understand how a parse tree/Syntax tree works and how to programm it.
So I will be using the recursive descent technique and making nodes for each production.

Cleaned up code, made another file for the tokenization(lexer) almost at parsing tree (

[ SOURCE CODE ]
│

1. ▼ LEXICAL ANALYSIS (Tokenizer) ◄─── finished here
   [ TOKEN STREAM ]
   │
2. ▼ SYNTAX ANALYSIS (Parser)
   [ ABSTRACT SYNTAX TREE (AST) ]
   │
3. ▼ SEMANTIC ANALYSIS (Type Checker)
   [ DECORATED AST ]
   │
4. ▼ INTERMEDIATE CODE GENERATION (IR)
   [ IR CODE ] (e.g., Three-Address Code, Bytecode)
   │
5. ▼ CODE OPTIMIZATION
   [ OPTIMIZED IR ]
   │
6. ▼ TARGET CODE GENERATION
   [ MACHINE CODE / ASSEMBLY ] (Final Executable)

“there are two types of programmers - those who have written a compiler and those who haven’t”
-Terry Davis

LME My own Compiler Devlog #2
I got the basic compiler pipeline working for Luna.I implemented a tokenizer that converts Luna source code into tokens, including:cik → exit token integers → integer literals; → semicolon token then added code generation that converts the tokens into x86-64 NASM assembly using the Linux exit syscall.For example: cik 42; gets compiled into assembly that exits the program with status code 42.I also fixed a bounds-checking bug in the token parser and verified that the generated executable runs correctly under Linux/WSL.The basic pipeline is now:Luna source → tokenizer → tokens → x86-64 assembly → executable

Next step is the Parse Tree

Building my own compiler (vexa compiler) devlog #1
Semicolon based, whitespace does not matter.
File ending will be .tr so main.tr.
Syntax language will be turkish.
Now writing the tokenization stuff 🫩

REDC2 DEVLOG 3 - squashed two nasty bugs
Spent today hunting down two bugs that were making the SSH terminal panel basically unusable.
Bug #1: crashing on select
Selecting a machine from the command bar threw a DuplicateIds exception and killed the terminal widget. Turns out Textual’s Widget.remove() is async — it just schedules the removal, it doesn’t happen instantly. My code was removing the old terminal widget and then immediately mounting a new one with the same hardcoded id (ssh-terminal), so the two calls raced each other and Textual saw two widgets claiming the same id at once. Fixed it by giving each terminal instance a unique id (ssh-terminal-1, ssh-terminal-2, …) instead of reusing one.
Bug #2: invisible typing in the command bar
Typing into the main redc2> input box showed nothing on screen even though the input was working fine under the hood. Textual’s Input widget defaults to a border: tall style that needs ~3 rows to actually render the text row. My CSS forced the input down to height: 1 without accounting for the border, so the text row got squeezed to zero height and effectively vanished. Fix: stripped the border and added proper padding on the compact input.
Both fixed now — dashboard select → terminal open → typing all work smoothly. Butter on warm bread. 🧈🍞

REDC2 Devlog 2 - Floating Terminal Feature
Date: Aug 16, 2026
So I added a floating terminal panel to REDC2. The whole thing took a few hours.
Why
The dashboard was fine but having all command output in a separate section meant you couldn’t see both the machine status and what you just ran at the same time. Wanted the output accessible with a quick keybind without cluttering the main view.
How
Added a new FloatingTerminal container that sits in an overlay layer. It’s reactive so toggling visibility is smooth. Ctrl+T brings it up/down. All command output gets mirrored there automatically via the logging pipeline.
Used Textual’s layer system to keep it from blocking the dashboard. Size and position are just CSS (width/height/offset), so it’s easy to customize.
The Issues
Initial CSS used right/bottom which Textual doesn’t support. Switched to offset. That fixed it.Paramiko had version issues with keys. Downgraded to 3.4.1 and added password auth support to the config since most people just want to use passwords anyway.SSH key format stuff is annoying. Just went with password auth as default and made it dead simple.
What Works
Toggle with Ctrl+TReal-time command outputScrollable history (max 2000 lines)Doesn’t block dashboard interactionWorks over SSH fine
What’s Left
Draggable terminal (low priority)Copy/paste in terminal (Textual limitation)Separate shell session option (would need more work)
It’s production ready though. Deployed to homelab and it just works.

Stats:
~100 lines of new code1 file modified (app.py)0 breaking changesWorks with password or key authNo new dependencies
Pretty solid for an afternoon’s work.

REDC2 devlog #1
Started REDC2, a small terminal tool for SSHing into my own machines (an Ubuntu server and a Raspberry Pi) without opening a new terminal every time. You type list, get an id for each machine, then select 0 and it just runs real ssh under the hood. No custom protocol, just a nicer front end for something I already do constantly.
Spent today mostly fixing bugs from the first rough version. select was calling ssh_into(), a function that didn’t exist, so picking a machine just crashed. Also had bad indentation, the quit/exit handling was nested inside the select block instead of next to it, and the main guard was indented inside main() so the script never actually ran.
Fixed both, then added colorama for colored output (green connecting, red errors, yellow on abort), and handling for when ssh isn’t installed at all, it checks /etc/os-release to find the distro and offers to install openssh instead of just crashing.
Machines are still hardcoded in a list at the top of the file, works but doesn’t scale. Next up is moving that into a config file so I don’t have to edit the script to add a machine, and adding a status check so list shows which machines are actually reachable.