Building Pylerium: A Tactical, Local-First Python Workflow Orchestrator in PyQt6

GitHub: https://github.com/Sh1tmunch3r/Pylerium.git

Tech Stack: Python 3.10+, PyQt6, SQLite, OpenGL/Software Renderer, Ollama API

License: MIT

Most modern developer tools look identical: clean, rounded corners, white or muted gray containers, and Electron wrappers that consume 1 GB of RAM just to render a button.

When designing Pylerium, I took the opposite approach. Pylerium is an air-gapped, local-first Python workflow orchestrator and tactical developer workbench wrapped in a high-density military HUD aesthetic inspired by games like Call of Duty: Black Ops II and Black Ops 6.

Here is a breakdown of why Pylerium was built, how the local execution engine operates, and how game interface design principles can make developer tools faster and more functional.

1. Why Bring Tactical HUD Design to Developer Tools? In military UI design, information density is critical. Pilots and tactical operators need real-time data—health, hardware telemetry, ammo counts, spatial coordinates, and thread states—presented without navigating buried sub-menus.

Modern IDEs often hide system telemetry or force developers to switch between heavy panel layouts. Pylerium translates tactical gaming HUD principles directly into developer workflow orchestration:

High-Density Viewports: System status, hardware metrics (frame times, triangle counts, GPU memory), and execution states are permanently pinned to dedicated viewports.

Aggressive Visual Hierarchy: Safety-orange active states (DEPLOY PROJECT, LOBBY) combined with industrial slate container borders and cyan diagnostic typography anchor your vision directly to active tasks.

Operational Workspaces: Instead of standard dropdown menus, the workflow is split into operational sectors:

Lobby: Project execution control, hardware telemetry, and squad status.

Workshop: Integrated code editor and PyInstaller executable compilation.

Maps: Visual DAG (Directed Acyclic Graph) workflow visualization.

Barracks & Assets: Local persistent storage, SQLite state inspection, and 3D mesh model inspection.

1. Technical Architecture & Core Features Pylerium isn't just a theme wrapper—it’s a performance-focused local task engine designed to run completely offline without cloud dependencies.

+-----------------------------------------------------------------------+
| PYLERIUM |
| (PyQt6 Custom UI Engine) |
+-------------------+-------------------------------+-------------------+
| LOBBY / MAPS | WORKSHOP | BARRACKS |
| (DAG Controller) | (Editor / Compiler) | (SQLite Storage) |
+-------------------+-------------------------------+-------------------+
| | |
v v v
+------------------+ +--------------------+ +-------------------+
| SQLite3 State | | Multi-Process Task | | Local Ollama AI |
| Persistence | | Execution Engine | | Drafting Engine |
+------------------+ +--------------------+ +-------------------+
Core Engine Highlights
Multi-Process DAG Orchestration: Executes complex Python workflow graphs across isolated background processes, preventing GUI freezing and ensuring thread safety.

SQLite State Persistence: All workspace states, execution logs, and workflow dependencies are stored locally in orchestration_data/shared.sqlite3.

3D Asset Inspection Viewport: Features a built-in software/OpenGL previewer for instant .obj and texture inspecting with real-time GPU/CPU frame telemetry.

ANSI-Enabled Terminal: Native terminal emulation with color code support and direct command passthrough.

Air-Gapped AI Drafting: Integrated with local Ollama instances to generate code snippets and assist in DAG pipeline setup without sending a single byte to external servers.

1. Designing for Zero Copyright Risk (Bring Your Own Assets) Because Pylerium draws heavy visual inspiration from tactical game lobbies, maintaining a clean open-source repository was a primary architectural goal.

The distribution uses a "Bring Your Own Assets" model:

Default Fallbacks: The codebase uses purely procedural vector grids, dark gradients, and custom SVG icons out of the box.

Asset Customization: Users can drop custom background wallpapers or textures into assets/backgrounds/ locally.

Strict Git Tracking: All local asset drops and temporary databases are isolated via .gitignore, keeping the public repository 100% code-focused and compliant.

1. Quickstart: Running Pylerium Locally To launch Pylerium from source, clone the repository and run the primary loadout menu:

Bash

Clone the repository

git clone https://github.com/Sh1tmunch3r/Pylerium.git
cd Pylerium

Install dependencies (PyQt6 + core utilities)

pip install -r requirements.txt

Launch the Tactical Command Center

python Systematic/loadout-menu.py
Compiling to a Standalone Executable
Pylerium includes built-in PyInstaller automation inside the Workshop tab. You can compile the entire workbench into a single, self-contained Windows executable (Pylerium.exe) directly from the UI or via PowerShell:

PowerShell
pyinstaller --noconfirm --onedir --windowed --icon="assets/icons/pylerium.ico" --name "Pylerium" "Systematic/loadout-menu.py"

1. What's Next for Pylerium? The core architecture is stable, test-backed, and ready for community expansion. Current focus areas on the development roadmap include:

[ ] Extended node types for visual DAG pipeline editing.

[ ] Expanded 3D shader previewing inside the asset viewport.

[ ] Custom macro bindings for rapid workflow execution.

Check out the code, run the integration test suite (python -m unittest discover -s Systematic), and feel free to submit pull requests or feature requests on GitHub!

Link: GitHub - Sh1tmunch3r/Pylerium