To quote Kiss âThese are my people and this is my crowdâ
I genuinely thought Linux Mint would be my final stop. It was close enough to pure Debian that I felt at home, but with enough convenience sprinkled in that dayâtoâday work didnât feel like a chore. Mint is a great âI need to get things doneâ distro â functional defaults, predictable behavior, and a desktop that doesnât fight you.
But if you hang around Linuxâfocused Discord servers long enough, something new and shiny will eventually wander across your path. And with juuuust enough daily frustrations â GPU weirdness, Wayland immaturity, a mysterious secondâscreen dead zone I could never solve â it was enough for me to reach for the Ventoy USB.
Iâm not one of those people who sampled a million distros before settling into Linux. When I switched to Debian as my daily driver all those years ago, it was a deliberate choice. I wanted to learn âLinuxâ from scratch: close to the metal, minimal fluff, no handâholding. And honestly, I still recommend Debian to anyone who likes IT. If you come from the server or infra world, itâs a great way to slide into userâfacing Linux.
Pop!_OS sits in a strange but appealing niche. Itâs Ubuntuâbased, but with a distinct personality. Calling System76 the Apple of the Linux world might be hyperbole, but theyâve definitely tapped into something similar: the idea that defaults, polish, and PRESENTATION matter.
I know some of my more hardcore Linux brethren â the ones who treat a TTY like a lifestyle choice â will insist that anything beyond a blinking cursor is for casuals. But the GUI, the window style, and the ease of setting perâmonitor wallpapers make Pop!_OS feel usable and personal in a way that clicks immediately.
What really surprised me, though, is how coherent it feels. Pop!_OS gives you modern tools without the usual Ubuntuâadjacent clutter, and the whole environment feels designed as a whole rather than stitched together from whatever components happened to be available. Mint is great, but letâs be honest: Nemo and GNOME Terminal arenât exactly peak UX, and Cinnamon can sometimes feel like a carefully curated shelf of unrelated parts rather than a single idea.
Pop!_OS, even with Cosmic still evolving, feels intentional â the tiling workflow is smooth, the hardware support is ahead of the curve, and the system has that rare sense of everything pulling in the same direction. And despite the polish, it still feels unmistakably Linux; hand a Windows user Mint and Pop sideâbyâside and theyâll gravitate toward Mintâs familiarity, but anyone whoâs lived in this ecosystem will immediately feel at home in Pop!_OS.
Cosmicâs future is still a moving target â maybe it becomes a full fork, maybe it ends up as a dropâin DE, maybe it grows into something we havenât seen in the Linux world yet. But even in its current state, itâs shockingly functional for something being built from the ground up. I was close to rolling my own Mint remix just to get the workflow I wanted, and Pop!_OS saved me from going full âcompileâyourâownâdistroâ mode. Itâs polished without pretending not to be Linux, opinionated without boxing you in, and coherent in a way most distros only gesture at. For now, thatâs exactly the level of chaos and control I want.
]]>Switching from Debian to Linux Mint was not a matter of abandoning stability or minimalism. It was a shift in priorities. Debian remains one of the cleanest, most disciplined Linux distributions available, and is for me very much what Linux is âsupposed to beâ. Its design philosophy is conservative by intent: minimal assumptions, and minimal surprises.
The tradeâoff is time. Debian gives you full control, but it also expects you to exercise that control. Debian is a distribution where you can get anything done if you have an hour.
Linux Mint sits at a different point on the spectrum. It is not trying to be a universal base system. It is trying to be a workstation. The defaults are tuned for everyday use, the desktop environment is configured for clarity rather than purity, and many of the small tasks that require manual configuration on Debian are handled automatically. The automation is not perfect, but it removes enough friction that it is as easy as old windows was to get to a working state (and easier than modern Windows i would argue).
That convenience is ultimately why I moved. I still appreciate Debianâs clean design and the way it exposes the underlying system without decoration. But for dayâtoâday work, Mint reduces the number of small interruptions that accumulate over time. External drives mount without argument. Network tools behave as expected. Desktop integration requires less manual wiring.
Debian remains the distribution I trust for longâterm stability and for environments where I want to control every detail. Mint is the distribution I reach for when I want to sit down, open the machine, and start working on something that is not âcomputer relatedâ, as in not tinkering but writing or something that âjust needs to wrokâ. The move was not about abandoning one philosophy for another. It was about choosing the environment that introduces fewer obstacles in the course of an ordinary day.
Joining the Linux Mint Discord ended up being part of the transition as well, and it made me think about how different the landscape was when I first moved to Linux. In the midâ2000s, nothing about the ecosystem was simple. World of Warcraft was still new enough that people were making spending-money by grinding characters for strangers, and the internet felt smaller, stranger, and far less curated. If you wanted to fix something on Linux, you didnât open a friendly chat server. You went a dozen pages deep into a search engine that still returned static HTML sites, hoping to find an archived forum thread where someone had encountered a vaguely similar problem years earlier. Realâtime help existed, but only in the form of IRC channels you found through rumor, and stepping into one felt like entering a workshop where everyone already knew each other and nobody had time for beginners. You learned by reading, experimenting, and breaking things until you understood them.
Today the barrier to entry is lower and the community is easier to reach, but the baseline level of preparation has dropped with it. What worries me is not the decline of search quality, but the shift in how people interact with information. We are in an inâbetween era where LLMs are becoming good enough to replace old search engines, but only if you know how to speak to them. It is the same skill we used to laugh about when someone typed a polite letter into Google asking for a recipe. Search has always been a language, and the language has changed. If you tell an LLM âmy hard drive doesnât work,â it will happily offer to sell you a new one. If you say âI booted a Debian 12 live USB and my old Windows 10 NTFS drive mounts readâonly and wonât let me rename files,â it can actually help. The difference is precision, context, and a functioning nonsense detector â the same instincts you needed when the first reply on a forum was âdelete system32.â
I enjoy helping people, and in open source that kind of collaboration is what keeps the ecosystem alive. But the combination of vague questions, weakened research habits, and an overreliance on AI to guess the problem makes me wonder how the next generation of enthusiasts will develop the curiosity and resilience that defined the earlier era of Linux.
]]>Running DeepSeek locally inside VS Codium made sense for one simple reason: it removes token limits, avoids external dependencies, and paired with a deâtelemetrized editor like Codium, it provides a fully offline coding assistant with none of the usual data collection overhead.
Before integrating DeepSeek into VS Codium, the system was running in a different configuration. The Intel Arc B580 originally handled the desktop, while the GTX 970 was reserved for CUDA workloads. This made sense for smaller models and for tools like InvokeAI, which automatically detect and prefer CUDA devices. The Arc stayed free for Vulkan applications and general desktop rendering, and the 970 handled the AI tasks.
That arrangement stopped working once the model size increased. DeepSeekâCoderâV2âLite requires roughly nine to ten gigabytes of VRAM for full offload, plus additional space for runtime buffers and the KV cache. The Arc B580 is a 12 GB card on paper, but with the desktop running on it, nearly two gigabytes were permanently occupied by the display stack. That left too little headroom for the model to load reliably.
To free the Arcâs VRAM, the display output had to be moved to the GTX 970. Under Xorg this is straightforward: the NVIDIA card becomes the primary display device, and the Arc is left completely idle until a Vulkan workload is launched. Once the desktop was running on the 970, the Arc reported roughly 10.5 GB of free VRAM, which is just enough for DeepSeekâCoderâV2âLite in Q4_K_M format.
This change was the turning point. With the display stack off the Arc, the model could finally load without falling back to CPU or failing during initialization.
With two GPUs present, Vulkan does not always select the correct device automatically. KoboldCpp in particular tends to prefer CUDA if it detects an NVIDIA card, even if Vulkan is requested. To avoid this, the Intel ICD file was explicitly exported:
export VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/intel_icd.json
This ensures that Vulkan compute work is routed to the Arc B580 rather than the GTX 970.
Once the ICD was set, the model could be launched through KoboldCpp:
koboldcpp-linux-x64 \
--model /path/to/DeepSeek-Coder-V2-Lite-Instruct-Q4_K_M.gguf \
--usevulkan \
--gpulayers 999 \
--contextsize 4096
Each flag serves a specific purpose.
usevulkan
Forces the Vulkan backend and prevents accidental fallback to CUDA or CPU.
gpulayers 999
Requests full layer offload. On the Arc B580, this results in complete GPU execution.
contextsize 4096
Keeps the KV cache within the available VRAM budget. Larger values risk exhausting memory during longer completions.
With these flags, the model loads entirely on the Arc and remains stable during extended coding sessions.
KoboldCpp exposes an OpenAIâcompatible API on port 5001. Continue can use this directly without modification.
In Continueâs settings:
Provider: OpenAI Compatible
Endpoint:
http://localhost:5001/v1
Model name: deepseek
API key: (empty)
Once configured, Continue sends all requests to the local DeepSeek instance. Code explanations, refactoring, and inline completions all run through the Arc GPU without involving cloud services.
The initial layout worked for smaller models, but DeepSeekâCoderâV2âLite needed nearly the entire VRAM budget of the Arc. The display stack alone consumed close to two gigabytes, leaving too little room for the model and its runtime buffers. Moving the desktop to the GTX 970 freed the Arc completely, allowing the model to load and run as intended.
The end result is a mixedâGPU system where each card has a clear role: the GTX 970 drives the desktop, and the Arc B580 handles all Vulkanâbased LLM workloads. This configuration allows a 2016 platform to run a modern coding model inside VS Codium with no external dependencies.
]]>When I built this system in 2016, NVIDIA was still pushing SLI as the next big thing. I even considered buying a second GTX 970, but the scaling numbers were already questionable and support was fading. So I stuck with one card and moved on.
Ironically, almost a decade later, the machine does run two GPUs â just not in any way NVIDIA intended. No SLI bridges, no linked rendering, just two independent cards doing completely different jobs.
The Gigabyte Z270XâGaming 5 has three fullâlength PCIe slots, which makes this setup straightforward:
The WiâFi card sits in the bottom slot because putting it in the middle slot blocks the Arcâs fan. The Arc gets the top slot for airflow and bandwidth, the 970 sits in the middle without complaint, and everything runs at PCIe Gen3 â which is fine for this workload.
Linux Mint 22.3 ships with an experimental Cinnamon Wayland session, so I tested it. With mixed GPUs (Intel + NVIDIA), it wasnât usable:
Switching back to the standard Cinnamon Xorg session fixed everything immediately. Arc handles the desktop and games, the 970 stays available in the background, and the system behaves predictably.
The main reason for keeping the 970 installed is simple: CUDA.
InvokeAI detects the NVIDIA card and uses it for model inference:
[InvokeAI]::INFO --> Using torch device: NVIDIA GeForce GTX 970
...
VRAM in use: ~3.0G
The Arc stays free for desktop rendering and Vulkan workloads, while the 970 becomes a dedicated AI accelerator. With only 4 GB VRAM itâs not fast â roughly 10 minutes for a 30âstep SDXL run â but it works reliably and keeps the system responsive.
This is a better use of an old GPU than letting it sit in a drawer.
I also tried running LM Studio, but it wasnât stable on this configuration. Even under Xorg, it consistently crashed during startup or model load. We tested different backends, toggled GPU settings, and tried both GPUs, but nothing made it usable.
Right now LM Studio simply doesnât behave well on this mixedâGPU, olderâplatform setup. It might improve with future updates, but at the moment itâs not an option here.
Itâs not a modern build, but it does exactly what I need: Arc for the desktop, 970 for AI, and a Z270 board quietly holding the whole thing together.
]]>Getting Intelâs new Battlemage GPU running smoothly on Linux turned out to be a mix of firmware archaeology, and a few strange quirks.
This machine started life as a 2016 self built gaming build, and like many aging PCs, itâs been through a long series of upgrades, sidegrades, and questionable decisions. The original build specs were these:
During itâs life it has hosted a number of different HDDâs, a sidegrade to a 1060 gtx 3gb GPU, and a Kingston NV2 M.2 1TB ssd. I also upgraded it with a ASUS PCE-AX3000 wifi card, getting that fucker to work is listed in another post.
The latest BIOS realeased for the system Mar 9, 2018, version F10b and I had updated to that by the end of 2018. But i havenât messed with it much when it comes to settings since then
On Linux Mint (Ubuntu 24.04 base), the Mesa stack already supports Battlemage well. 3D acceleration, Vulkan, desktop compositing â all of that worked immediately.
VLC and Celluloid (mpv) crashed instantly on video playback.
Terminal output showed:
libva info: Trying to open ... iHD_drv_video.so
Bus error (core dumped)
This revealed the real culprit:
VLC loads VAAPI before it reads user preferences, so even disabling hardware decoding didnât help. The crash happened too early in the startup sequence.
Instead of ripping out drivers or modifying the system, the cleanest solution was to block VAAPI only for VLC, using an environment variable.
I created:
~/bin/vlc-no-vaapi
with:
#!/bin/bash
LIBVA_DRIVER_NAME=none exec /usr/bin/vlc "$@"
This prevents VLC from loading the unstable VAAPI driver, while leaving the rest of the system untouched.
To make it convenient, I added a .desktop launcher pointing to the script:
[Desktop Entry]
Type=Application
Name=VLC (No VAAPI)
Exec=/home/the66monkey/bin/vlc-no-vaapi
Icon=vlc
Terminal=false
Categories=AudioVideo;Player;Video;
Now VLC launches normally from the desktop, without crashes.
GravityMark 1440p Results (Linux Vulkan):
Vulkan: 122.5 FPS
Vulkan Ray Tracing: 38.2 FPS
Summary:
Battlemage delivers excellent Vulkan performance on Linux Mint.
Ray tracing works, but on a 2015 CPU + Z270 board, the GPU canât stretch its legs fully. On a modern platform, the RT score would climb significantly.
Mapping Wi-Fi networks on a non-rooted Android device can feel like a dead endâuntil you discover Termux. In this post weâll unpack two companion scripts, wifi-map.sh and wifi-scout.sh, that turn a ZTE Axon 7 into a portable scout device and Wi-Fi reconnaissance toolkit. Youâll learn how each script works, how they collect GPSâtagged scans and network data, and how to deploy them over ADB on a stock (but debloated) device.
Before you begin, ensure the following are in place:
termux-wifi-scaninfo / termux-wifi-connectioninfotermux-locationjq, timeout, ip, arp, awk, grep, cutnmap installed in Termux for subnet ARP scanning/sdcard/logs)Passive âwarwalkingâ scan: tag every beacon frame with GPS coordinates and log SSID, BSSID, channel and encryption.
for cmd in termux-wifi-scaninfo jq timeout termux-location; do
command -v "$cmd" >/dev/null || { echo "Missing: $cmd"; exit 1; }
done
/sdcard/logswifi-map-YYYYMMDD_HHMMSS.logjq.termux-wifi-scaninfo (10âs timeout)jq into TSV linesMyNetworkSSID 12:34:56:78:9A:BC CH:11 RSSI:-67 WPA2/WPA3
Active reconnaissance on the currently connected AP: GPS tag + connection details + local host and subnet discovery.
termux-wifi-connectioninfo, ip, arp, nmap (optional), etc.termux-wifi-connectioninfo to capture SSID, BSSID, IP, link speed, frequency and RSSI.getprop | grep dns.ip neigh show to list local neighbors..1â.254 and logs âX.X.X.Y is upânmap is present, runs an ARPâping scan on X.X.X.0/24 with a 45âs timeout./proc/net/arp, extracts each MAC, finds OUI vendor in ~/storage/shared/oui.txt.Just push the files to the device with something like
adb push wifi-map.sh /storage/scripts/wifi-map.sh
then copy from the scripts folder on the device with Termux to the Termux-Widget folder.
cp -f ./* ~/.shortcuts/
you might also have to make it executable
chmod +x (filename)
---
## Viewing Your Logs
All logs land in `/sdcard/logs`. You can pull them down for analysis:
```bash
adb pull /sdcard/logs ~/axonscout-logs
Open the .log files in your favorite editor or import into mapping software.
With these scripts, your unrooted ZTE Axon 7 becomes a complete scouting and network-recon platform. You get:
Take this further by:
Every step is in Bash, so customize as you see fit. Happy scouting!
#!/data/data/com.termux/files/usr/bin/bash
# wifi-map.sh â Passive scan with GPS tagging (for warwalking use)
# Dependencies check
for cmd in termux-wifi-scaninfo jq timeout termux-location; do
command -v "$cmd" >/dev/null || {
echo "Missing: $cmd" >&2
exit 1
}
done
# Log directory
LOG_DIR="/sdcard/logs"
mkdir -p "$LOG_DIR"
LOG_FILE="$LOG_DIR/wifi-map-$(date +%Y%m%d_%H%M%S).log"
# Channel helper
freq_to_channel() {
local f=$1
if [ "$f" -ge 2412 ] && [ "$f" -le 2484 ]; then echo $(( (f - 2407) / 5 ))
elif [ "$f" -ge 5170 ] && [ "$f" -le 5825 ]; then echo $(( (f - 5000) / 5 ))
else echo "?"; fi
}
# Get GPS snapshot
GPS=$(timeout 10 termux-location --provider gps --request once 2>/dev/null)
if [ -n "$GPS" ]; then
LAT=$(echo "$GPS" | jq -r '.latitude')
LON=$(echo "$GPS" | jq -r '.longitude')
ACC=$(echo "$GPS" | jq -r '.accuracy')
echo "GPS: lat=$LAT lon=$LON acc=${ACC}m" > "$LOG_FILE"
else
echo "GPS: unavailable or timed out" > "$LOG_FILE"
fi
# Run scan with timeout
SCAN_JSON=$(timeout 10 termux-wifi-scaninfo 2>/dev/null)
# Handle timeout or empty result
if [ -z "$SCAN_JSON" ] || [ "$SCAN_JSON" = "[]" ]; then
echo "Scan failed or returned no data. Check permissions or location services." >> "$LOG_FILE"
exit 1
fi
# Parse and log results
echo "$SCAN_JSON" | jq -r '.[] |
{
ssid: .SSID,
bssid: .BSSID,
freq: .frequency,
level: .level,
caps: .capabilities
} |
[.ssid, .bssid, (.freq|tostring), (.level|tostring), .caps] |
@tsv' | while IFS=$'\t' read -r SSID BSSID FREQ RSSI CAPS; do
CHAN=$(freq_to_channel "$FREQ")
ENC=$(echo "$CAPS" | grep -Eo "WPA3|WPA2|WPA|WEP" | tr '\n' '/' | sed 's|/$||')
[ -z "$ENC" ] && ENC="OPEN"
printf "%-30s %-18s CH:%-2s RSSI:%-4s %s\n" "$SSID" "$BSSID" "$CHAN" "$RSSI" "$ENC"
done >> "$LOG_FILE"
#!/data/data/com.termux/files/usr/bin/bash
# wifi-map.sh â Passive scan with GPS tagging (for warwalking use)
# Dependencies check
for cmd in termux-wifi-scaninfo jq timeout termux-location; do
command -v "$cmd" >/dev/null || {
echo "Missing: $cmd" >&2
exit 1
}
done
# Log directory
LOG_DIR="/sdcard/logs"
mkdir -p "$LOG_DIR"
LOG_FILE="$LOG_DIR/wifi-map-$(date +%Y%m%d_%H%M%S).log"
# Channel helper
freq_to_channel() {
local f=$1
if [ "$f" -ge 2412 ] && [ "$f" -le 2484 ]; then echo $(( (f - 2407) / 5 ))
elif [ "$f" -ge 5170 ] && [ "$f" -le 5825 ]; then echo $(( (f - 5000) / 5 ))
else echo "?"; fi
}
# Get GPS snapshot
GPS=$(timeout 5 termux-location --provider gps --request once 2>/dev/null)
if [ -n "$GPS" ]; then
LAT=$(echo "$GPS" | jq -r '.latitude')
LON=$(echo "$GPS" | jq -r '.longitude')
ACC=$(echo "$GPS" | jq -r '.accuracy')
echo "GPS: lat=$LAT lon=$LON acc=${ACC}m" > "$LOG_FILE"
else
echo "GPS: unavailable or timed out" > "$LOG_FILE"
fi
# Run scan with timeout
SCAN_JSON=$(timeout 10 termux-wifi-scaninfo 2>/dev/null)
# Handle timeout or empty result
if [ -z "$SCAN_JSON" ] || [ "$SCAN_JSON" = "[]" ]; then
echo "Scan failed or returned no data. Check permissions or location services." >> "$LOG_FILE"
exit 1
fi
# Parse and log results
echo "$SCAN_JSON" | jq -r '.[] |
{
ssid: .SSID,
bssid: .BSSID,
freq: .frequency,
level: .level,
caps: .capabilities
} |
[.ssid, .bssid, (.freq|tostring), (.level|tostring), .caps] |
@tsv' | while IFS=$'\t' read -r SSID BSSID FREQ RSSI CAPS; do
CHAN=$(freq_to_channel "$FREQ")
ENC=$(echo "$CAPS" | grep -Eo "WPA3|WPA2|WPA|WEP" | tr '\n' '/' | sed 's|/$||')
[ -z "$ENC" ] && ENC="OPEN"
printf "%-30s %-18s CH:%-2s RSSI:%-4s %s\n" "$SSID" "$BSSID" "$CHAN" "$RSSI" "$ENC"
done >> "$LOG_FILE"
uname -r
If older, consider upgrading via backports or using a newer Debian release.
sudo apt update
sudo apt install firmware-iwlwifi
sudo modprobe -r iwlwifi
sudo modprobe iwlwifi
The AX200âs Bluetooth runs over a USB header cable, so make sure that little cable is plugged into your motherboard!
sudo apt install bluetooth bluez bluez-firmware
echo 'options btusb enable_autosuspend=0' | sudo tee /etc/modprobe.d/btusb.conf
If bluetoothctl still says No default controller available, try:
sudo apt install firmware-intel-sound
sudo modprobe -r btusb
sudo modprobe btusb
dmesg | grep -iE 'firmware|btusb|hci'
I know there are some other programs out there that does the same and better, but they are all very old and i wanted to make sure it worked on modern machine.
Check it out here: traffic-limiter GitHub repo
I wanted a simple modern and tested way to just limit the network usage.
When i have fixed everything else on my machine i hope to move on to allowing the user to limit the speed per/application as that was my original need.
]]>