The Linux Thread - The Autist's OS of Choice

  • 🏰 Deploying update to the Tatarus security page. If you encounter issues, post here.
  • Want to keep track of this thread?
    Accounts can bookmark posts, watch threads for updates, and jump back to where you stopped reading.
    Create account
Are you talking installer sizes? WINEPREFIX bloats with more than tens of megabytes whenever I need to run some retarded dot not shit, and it takes forever to install even on my high-speed 56k dial-up here in Lesotho.

And that's also ignoring the massive directx runtimes, I wrote "runtimes" plural for a reason. paintdotnet is a bloated slopfest no matter how you look at it.
Oh you are one of those that like to pretend it is still 1998 and anything over 20mb is a PITA.

.NET framework has been a thing now for 25 years and is included as part of the app. The website says it needs a GPU with support for Direct X 11. Direct X 11 is 18 years old.

These are standard stuff that is installed on Windows and the installer sizes are nowhere as big as 5gb or whatever rubbish you were saying.

None of this makes it slop because no matter how many times you repeat it. People overuse this term now and like others on here you are wearing out its use.
 
Last edited:
Are you talking installer sizes? WINEPREFIX bloats with more than tens of megabytes whenever I need to run some retarded dot not shit, and it takes forever to install even on my high-speed 56k dial-up here in Lesotho.

And that's also ignoring the massive directx runtimes, I wrote "runtimes" plural for a reason. paintdotnet is a bloated slopfest no matter how you look at it.
I was trying to get fling trainers working but the dotnet framework wont install in a 64 bit wine prefix when it used to,its fucking retarded because it used to work on older wine versions

I got the fling trainer working in bottles because bottles let me install the dotnet framework for whatever reason but that means I have to run Steam through bottles to run it within the same prefix

I know the solution and have it, its just fucking stupid because some tranny broke the WoW64 installer for 32 bit software to run in 64 bit wine prefixes and wine staging, apparently wine-devel works for it

I ended up dual-booting with Tiny 11 LTSC just because I care about functionality more than FOSS idealism and because my PC is fast it boots within seconds its not a major hassle
 
Last edited:
I ended up dual-booting with Tiny 11 LTSC just because I care about functionality more than FOSS idealism and because my PC is fast it boots within seconds its not a major hassle
Good decision, installing malware can sometimes be difficult on Linux unless you use Arch with the AUR like all Arch users recommend until another malicious AUR package gets pushed. Some of the 'bundled software' with those 'trainers' might not work right under Wine.
 
Good decision, installing malware can sometimes be difficult on Linux unless you use Arch with the AUR like all Arch users recommend until another malicious AUR package gets pushed. Some of the 'bundled software' with those 'trainers' might not work right under Wine.
The funny thing is, AUR malware has already been solved

Garuda has their own arch repository with Chaotic-AUR and it basically compiles and vets packages to prevent malware from being spread unwittingly and even comes with KDE discover or whatever flathub client you like and want to just avoid the AUR entirely

Garuda despite being half German and half Jeet is surprisingly unpozzed and didn't rainbowify their forums in June and denied using Age verification

Its really flashy and gets the ire of a lot of neckbeards and redditors but its been my main distro because it is the most stable and easiest to use Arch based distro besides maybe SteamOS or CachyOS

I'd rather have flashy RGB gamer edgelord design than troonshit tbh, its a far lesser evil
 

Attachments

  • Screenshot_20260903-171540.png
    Screenshot_20260903-171540.png
    305 KB · Views: 42
Last edited:
Good decision, installing malware can sometimes be difficult on Linux unless you use Arch with the AUR like all Arch users recommend until another malicious AUR package gets pushed. Some of the 'bundled software' with those 'trainers' might not work right under Wine.
Funny, I've never had a problem. I am not a fucking moron, though, and don't yay install any old shit.

Using the AUR is fine as long as you learn to mitigate the risks properly.
 
So... I've been fiddling with local inference again. In other words: "I deliberately overspecced my PC for vidya, and I don't play enough vidya to put my GPU through its paces. So I'm fiddling with open weight LLMs up to and including the 14B parameter range." That's what can comfortably fit within my GPU, and frankly, I don't wanna waste RAM and swap space trying to get a 30B model running in pure text mode.

CONSTRAINTS:

1. This is purely in Ollama. No Open WebUI, no Chatbox, no Alpca. 100% plaintext within my terminal emulator.
2. I'm not using any external AI tooling to have some sort of agent in my shell, my file manager, or any of that crap. Pure LLM with standard piped commands, and nothing else.
3. I'm not measuring tokens, context, or any of that crap. This is a WYSIWYG exercise.
4. My prompting skill is total dogshit ass, and these models are capable of fantastic feats while completely shitting the bed in the process even if I use boilerplate prompts.

THE TEST:

The AI agent will be fed the following prompt: timedatectl | ollama run $insert_model_here "Explain this output to me as a Linux user."

Control output as below. It has to explain to me what each parameter means.

Code:
               Local time: Fri 2026-09-04 05:14:45 EDT
           Universal time: Fri 2026-09-04 09:14:45 UTC
                 RTC time: Fri 2026-09-04 09:14:45
                Time zone: America/New_York (EDT, -0400)
System clock synchronized: yes
              NTP service: active
          RTC in local TZ: no

THE ROSTER:

I have the below four models in Ollama. I've fiddled with others in the past, but these are the ones I've got disk space dedicated for at hte moment

Code:
NAME                    ID              SIZE      MODIFIED     
nemotron-mini:latest    ed76ab18784f    2.7 GB    4 hours ago     
qwen3.5:9b              6488c96fa5fa    6.6 GB    4 hours ago     
gemma4:12b              4eb23ef187e2    7.6 GB    5 hours ago     
qwen3:14b               bdbd181c33f2    9.3 GB    11 hours ago

LET THE BATTLE BEGIN. FIRST CONTENDER: nemotron-mini:4b by NVIDIA

Code:
 Sure, I'd be happy to explain this output to you as a Linux user. Here's a breakdown of the output:

* The first line shows that the system time is set to Friday, September 4, 2026, and the local time is 05:21:56 EDT. The local time is set in the Eastern Daylight Time (EDT) zone and the offset is -0400, which means it's four hours 
behind Coordinated Universal Time (UTC).
* The second line indicates that the universal time is Friday, September 4, 2026, 09:21:56 UTC. UTC is the same as Coordinated Universal Time, but it doesn't observe daylight saving time.
* The third line shows that the system clock is synchronized with the local time, meaning that the system clock is in sync with the local time zone.
* The last two lines indicate that the Real-Time Clock (RTC) is not in local time zone and that the NTP service is active. The NTP service provides the system with a network time synchronization service.

The results are satisfactory. This is by far the smallest model I run at 4B parameters. SECOND CONTENDER: Qwen3.5:9b by Alibaba Cloud

Code:
Thinking...
Here's a thinking process that leads to the suggested explanation:

1.  **Analyze the Request:**
    *   **Input:** A block of text showing system time information (Local time, Universal time, RTC time, Time zone, Sync status, NTP service, RTC TZ).
    *   **User Persona:** Linux user.
    *   **Goal:** Explain what this output means in simple, actionable terms relevant to a Linux environment (likely output from `timedatectl`).
    *   **Context:** The date is September 4, 2026 (future relative to now, but irrelevant to the technical meaning). The timezone is EDT.

2.  **Analyze the Input Data (Line by Line):**
    *   `Local time: Fri 2026-09-04 05:25:48 EDT` -> This is what you see on the screen in your region.
    *   `Universal time: Fri 2026-09-04 09:25:48 UTC` -> The global standard time (no offset).
    *   `RTC time: Fri 2026-09-04 09:25:48` -> Real Time Clock on the motherboard hardware. Usually matches UTC when in local TZ: no.
    *   `Time zone: America/New_York (EDT, -0400)` -> The configured timezone string and abbreviation. Offset is -4 hours.
    *   `System clock synchronized: yes` -> The system clock has been synchronized with an external source (NTP). It's accurate.
    *   `NTP service: active` -> Chrony or systemd-timesyncd is running in the background to keep time precise.
    *   `RTC in local TZ: no` -> This is a crucial technical detail. It means the BIOS/CMOS clock stores UTC time, not local time. The OS applies the timezone offset on top of that.

3.  **Determine the Explanation Strategy:**
    *   **Tone:** Technical but accessible (like a senior colleague explaining to a junior).
    *   **Structure:** Break it down by component (What does this mean? Why does it matter?).
    *   **Key Actionable Advice:** What should the user do with this info? (Usually, none is needed if all are "good," but maybe explain how to change settings if they want to).
    *   **Visual Aids:** Use bolding and bullet points for readability.

4.  **Drafting the Content - Section by Section:**

    *   **Introduction:** Identify the command source (`timedatectl`). State that everything looks healthy/configured correctly.
    *   **Deep Dive into the Fields:**
        *   *Local vs. Universal:* Explain the offset (EDT is UTC-4). 5:25 AM local vs 9:25 AM UTC. Math check: $5 + 4 = 9$. Correct.
        *   *RTC (Real Time Clock):* Explain hardware clock vs. OS clock. "no" means BIOS stores UTC. This is the modern best practice.
        *   *NTP/Sync:* Explain why accuracy matters (logs, authentication, Docker, Kubernetes).
    *   **The "So What?" Section:** Is this normal? Yes. Should you change it? Only if specific requirements exist (e.g., running a server in a different region).
    *   **Troubleshooting/Commands:** Give commands to verify or change settings just in case they need to know (`timedatectl set-ntp`, `timedatectl list-timezones`).

5.  **Refining the Output (Self-Correction/Polishing):**
    *   *Correction:* Wait, check the date again. It says 2026. That's a future date relative to my current training cut-off, but that doesn't matter for the explanation. I should focus on the *current* status, not the year.
    *   *Clarification:* Make sure to emphasize that "RTC in local TZ: no" is actually preferred now. Some users think they need it "yes," but modern OS (systemd) prefers UTC RTC + Timezone setting. I should mention that this 
setting implies the hardware clock holds UTC.
    *   *Formatting:* Use code blocks for commands.

6.  **Final Review against User Persona:**
    *   A Linux user cares about `timedatectl`. They might care about logs and authentication failures due to time drift.
    *   Keep it concise. Don't just translate the text, explain the *implications*.

7.  **Final Polish (similar to the provided good response):**
    *   Start with the "TL;DR".
    *   Break down the fields clearly.
    *   Add a section on why you should care (security, containerization).
    *   Mention commands to interact with this data.

**(Self-Correction during drafting):** I noticed the date is 2026. I won't explicitly say "Oh, that's future," because it might confuse them about the output format. I will treat the content as current data presented in the prompt. 
I should mention `timedatectl` specifically as that's the tool generating this.

8.  **Final Output Generation** (Proceed to generate response based on these thoughts).
...done thinking.

This output is likely generated by the `systemd-timesyncd` or `chrony` service status via the `timedatectl` command. It tells you how your Linux system is tracking time and ensuring accuracy.

Here is a breakdown of each line for a Linux user:

### 1. Time Display
*   **Local time:** The time displayed on your terminal and file timestamps. Right now, it's 05:25 AM EDT in the Eastern US (America/New_York).
*   **Universal time (UTC):** The global standard time offset to GMT/Coordinated Universal Time. Since we are in EDT (-0400), your local time is 4 hours *behind* UTC. (5:25 + 4 = 9:25 UTC).

### 2. RTC (Real Time Clock)
*   **RTC in local TZ: no**
    *   **Meaning:** Your motherboard BIOS/CMOS clock stores time in **UTC**, not your local timezone. The OS then applies the timezone offset when you look at the system time.
    *   **Why this is good:** This is the modern standard (systemd recommendation). It prevents issues if you travel to a different region or change timezones on the host, keeping your hardware clock consistent across servers 
regardless of location.

### 3. System Time Accuracy
*   **System clock synchronized: yes**
    *   Your system clock is currently accurate according to an external network time server.
    *   If this were `no`, your clock might drift (e.g., due to NTP service stopping or a bad leap second), which can cause authentication issues for SSH (OpenSSL), certificate validation, or container scheduling (Kubernetes).
*   **NTP service: active**
    *   The daemon responsible for syncing time is running. On older systems, this might be `systemd-timesyncd`, but on most modern distributions, it is `chronyd`.

---

### Summary & Verification
**Current Status:** ✅ **All green.** Your system has accurate hardware time (UTC), the correct timezone setting is applied, and NTP is actively keeping your system clock in sync.

### How to interact with this
If you want to change these settings, here are the relevant commands:

**1. Check the status again**
```bash
timedatectl status
```

**2. Force enable/disable NTP (if needed)**
```bash
# Ensure automatic syncing is ON
sudo timedatectl set-ntp true

# Or disable it if you want to set it manually only
sudo timedatectl set-ntp false
```

**3. Set a new timezone**
```bash
sudo timedatectl set-timezone America/Los_Angeles
```

**4. Check your system clock file (Legacy)**
While `timedatectl` is the standard now, some older software looks at `/etc/localtime`. On most modern systems, you don't need to touch this unless you are migrating from a non-systemd distro.

### Why does this matter?
*   **Log Integrity:** Logs timestamped with incorrect UTC vs. Local time can cause confusion during incident investigations.
*   **Security:** If `NTP service` is not active, an attacker could attempt to manipulate your system clock to bypass certificate validations (though modern Linux usually detects this).
*   **Containerization:** Docker/Podman and Kubernetes often fail if the host time drifts significantly from UTC standards.

**TL;DR:** You are configured correctly for a standard modern Linux server or desktop environment. No action required unless you specifically need to move to a different timezone or disable network time sync.

Took a whole lot of resources just to overexplain what timedatectl does and offer suggestions for stuff I never asked about. Whatever, just barely acceptable. THIRD CONTENDER: Gemma4:12b by Google.

Code:
Thinking...
A standard Linux `timedatectl` (or similar system clock utility) output.
Linux user (needs technical accuracy but clear explanations of what the fields mean).
Explain each line of the output to help the user understand their system's time configuration.

    *   `Local time: Fri 2026-09-04 05:30:20 EDT`: The clock as displayed to the user based on their configured timezone.
    *   `Universal time: Fri 2026-09-04 09:30:20 UTC`: The standardized time (Greenwich Mean Time/Coordinated Universal Time).
    *   `RTC time: Fri 2026-09-04 09:30:20`: The hardware clock (Real Time Clock) on the motherboard.
    *   `Time zone: America/New_York (EDT, -0400)`: The name of the timezone file and the current offset from UTC.
    *   `System clock synchronized: yes`: Whether the OS is currently syncing with an external source (NTP).
    *   `NTP service: active`: Whether the Network Time Protocol daemon is running.
    *   `RTC in local TZ: no`: Whether the hardware clock is set to local time or UTC.

    *   *Introduction:* Identify the command that likely produced this (likely `timedatectl`).
    *   *Section 1: The Three Types of Time.* (Local, Universal, RTC). This is the most important distinction for a Linux user.
    *   *Section 2: Timezone Configuration.*
    *   *Section 3: Synchronization Status.* (NTP).
    *   *Technical Tip:* Explain why "RTC in local TZ: no" is the preferred setting for Linux.

    *   *Local Time:* It's what you see in your terminal or GUI.
    *   *Universal Time (UTC):* This is the standard for servers/internet. It avoids confusion with daylight savings.
    *   *RTC Time:* This is the "Hardware Clock."
    *   *Comparison:* Note that in this specific output, UTC and RTC are the same. This is the "correct" configuration for Linux.

    *   *Time Zone:* `America/New_York` is the ID, `EDT` is the abbreviation, `-0400` is the offset.
    *   *Synchronization:* `System clock synchronized: yes` means it's talking to a server.
    *   *NTP Service:* `active` means the background worker is running.
    *   *RTC in local TZ:* This is a common point of confusion. Explain that "no" means the hardware clock is in UTC (standard for Linux), while "yes" would mean it's in Local Time (often used by Windows).

    *   Keep it professional but accessible.
    *   Use formatting (bolding, bullet points) for readability.
    *   Add a "Why does this matter?" section to provide context (e.g., why UTC is better for logs).
...done thinking.

This output is the standard output of the `timedatectl` command in Linux. It provides a comprehensive look at how your system handles time, timezones, and network synchronization.

Here is a breakdown of what each line means for you as a Linux user:

### 1. The Three Types of Time
The first three lines compare the three different "clocks" your system tracks:

*   **Local time:** This is the time as it appears to you. It takes your system's hardware clock and adjusts it based on your selected timezone and Daylight Saving Time (DST) rules.
*   **Universal time (UTC):** This is the "standard" time used by the internet, servers, and databases. It does not change for daylight savings. **In Linux, it is best practice for your system to perform its internal calculations in 
UTC.**
*   **RTC time (Real Time Clock):** This is the time kept by the hardware clock on your motherboard (the chip that keeps the clock running even when the computer is turned off).

### 2. Time Zone Configuration
*   **Time zone: America/New_York (EDT, -0400):**
    *   `America/New_York` is the specific database entry for your location.
    *   `EDT` confirms you are currently in Eastern Daylight Time.
    *   `-0400` means your local time is currently 4 hours behind UTC.

### 3. Synchronization Status
These lines tell you if your computer is actually talking to the internet to keep the time accurate.
*   **System clock synchronized: yes**: This means your system has successfully communicated with an NTP (Network Time Protocol) server and has adjusted the clock to match the global standard.
*   **NTP service: active**: This confirms that the background service (the "daemon") responsible for syncing your clock is currently running.

### 4. The "RTC in local TZ" Setting
*   **RTC in local TZ: no**:
    *   **This is an important one.** In the Linux world, the standard is to keep the Hardware Clock (RTC) set to **UTC**.
    *   If this were set to "yes," your hardware clock would be set to your local time. This is often the default for Windows machines.
    *   Because yours is "no," your system is correctly following the Linux standard: The hardware clock stays in UTC, and the OS handles the conversion to "Local Time" for you.

---

### Summary for the User:
**Your system is configured perfectly.** 

It is successfully syncing with network time servers, it knows exactly what timezone you are in, and it is following the Linux standard of keeping the hardware clock in UTC. You don't need to change anything.

Better than Qwen3.5:9b. More informative than nemotron-mini. Still more effort spent on a comparatively simple task. Firmly "good enough." LAST CONTENDER: Qwen3:14b by Alibaba Cloud

Code:
Thinking...
Okay, let's see. The user provided a system time output and wants an explanation as a Linux user. I need to break down each line and explain what they mean.

First, the local time is listed as EDT, which is Eastern Daylight Time. That's UTC-4. The universal time is UTC, which is four hours ahead. So the local time is 5:33 AM, and UTC is 9:33 AM. That makes sense because of the time zone 
difference.

The RTC time is the same as the universal time. RTC stands for Real-Time Clock, which is the hardware clock on the motherboard. So the system's hardware clock is set to UTC, not local time. That's important because some systems use 
UTC for the RTC, especially if they're in different time zones. The user might be confused if they think the RTC is using local time.

Time zone is America/New_York, which is EDT. The system clock is synchronized, and NTP is active. That means the system is using Network Time Protocol to keep the time accurate. The RTC in local TZ is no, which confirms that the RTC 
is using UTC, not the local time zone. This is a common setup to avoid issues when changing time zones.

I should explain each part step by step, maybe mention why RTC is set to UTC, how NTP works, and the implications of the time zone settings. Also, note that if the user is in a different time zone, the RTC remains UTC, which is 
standard for Linux systems. Maybe mention that if they need to change the time zone, the system will adjust the local time accordingly, but the RTC stays in UTC.
...done thinking.

This output provides details about your system's **time configuration** and **synchronization status**. Let's break it down line by line:

---

### **1. Local Time:**
```
Local time: Fri 2026-09-04 05:33:12 EDT
```
- **Local time** is the time shown on your system based on your **time zone** (America/New_York).
- **EDT** (Eastern Daylight Time) is the time zone you're in, which is **UTC-4** (4 hours behind Coordinated Universal Time).
- So, your system shows **5:33 AM** on **September 4, 2026**, in the **Eastern Time Zone**.

---

### **2. Universal Time (UTC):**
```
Universal time: Fri 2026-09-04 09:33:12 UTC
```
- **UTC** (Coordinated Universal Time) is the **global time standard** (used by computers and networks).
- Since your local time is **EDT (UTC-4)**, UTC is **4 hours ahead** of your local time.
- So, **9:33 AM UTC** corresponds to **5:33 AM EDT**.

---

### **3. RTC Time:**
```
RTC time: Fri 2026-09-04 09:33:12
```
- **RTC** (Real-Time Clock) is the **hardware clock** on your motherboard (battery-powered).
- The RTC is set to **UTC** (same as "Universal time"), not local time.
- This is the **standard configuration** for Linux systems, as it avoids confusion when changing time zones or moving between regions.

---

### **4. Time Zone:**
```
Time zone: America/New_York (EDT, -0400)
```
- Your system is using the **America/New_York** time zone (which corresponds to **EDT**).
- The **-0400** indicates the **offset from UTC** (4 hours behind UTC during daylight saving time).

---

### **5. System Clock Synchronized:**
```
System clock synchronized: yes
```
- Your system's **software clock** is synchronized with an external time source (via **NTP**, below).
- This ensures your system time is accurate and consistent with global time standards.

---

### **6. NTP Service:**
```
NTP service: active
```
- **NTP** (Network Time Protocol) is running and actively synchronizing your system's time with internet time servers.
- This keeps your system clock accurate, even if the hardware clock (RTC) drifts slightly over time.

---

### **7. RTC in Local Time Zone:**
```
RTC in local TZ: no
```
- This confirms that your **RTC is not set to local time** (it's using **UTC**, as shown above).
- If this were `yes`, the RTC would use your local time zone (e.g., EDT), which could cause issues if you change time zones (e.g., if you move to a different region).

---

### **Why is this important?**
- **RTC in UTC** is the **standard** for Linux systems. If you change your time zone (e.g., from EDT to EST), your system will adjust the **local time** without affecting the **RTC** (which remains in UTC).
- If the RTC were set to local time, changing time zones could cause **incorrect time offsets**.

---

### **Summary:**
- Your system is correctly configured with **NTP** to keep time accurate.
- The **RTC** (hardware clock) is set to **UTC**, which is standard for Linux.
- Your **local time** is **EDT (UTC-4)**, and the **UTC time** is 4 hours ahead.
- Everything is synchronized and ready to handle time zone changes without issues.

Let me know if you'd like to change the time zone or configure NTP manually!

Roughly similar answer quality to Gemma4:12b. Very slightly better. If I cared enough to nitpick, I'd probably find more faults. Either way. It passed. All four models passed the smell test. That's great. Funnily enough, this is the first time that I've actually had all four models complete the task. Both Qwens and Gemma4 got trapped in reasoning loops and never generated an answer when I asked it to explain "uname -a" because their older datasets kept tripping up over how I run Fedora 44, and they still think 39-41 are current.

Am I one step closer to Satya Nadella's "agentic" future? Fuck no. Will this prevent me from using ChatGPT and Claude? Again: Fuck no. Are these models genuinely useful if I had appropriate work to give them? Probably. Do I have any such work to give it beyond novelties for comparison's sake? Again: Fuck no. This is just a novelty to me more than anything else. While everyone else gets to fuck around with the fun AI that makes cancerous slop and deepfakes, I get to play with AI that can barely escape its own chain of reasoning. Hooray... (he lied).
 
My damn WiFi keeps cutting out and I can't tell if its guix, my WiFi adapter or just shitty WiFi. So I took my mesh WiFi thing and hardwired my thinkpad to it. Probably just get another one of those to put back where i had it.
 
Why not just use llama.cpp straight instead of the bloated ollama wrapper, if you're forgoing the webui etc?

Ollama's much easier for me to get up and running without fine tuning jack. It's literally "ollama pull, ollama list, command | ollama run whatever "$PROMPT_GOES_HERE," ollama rm whatever, and that's my lot.

Absolutely, 100% a skill issue on my part: I don't have the patience to sit down and get familiar with pure llama.cpp.

Frame it like this: I know how to pipe Ollama into my commands for arbitrary reasons, I actually have fiddled with front-ends like Alpca, Chatbox, and Open WebUI, but to that end? Knowledge drops off a fucking cliff because Hugging Face wants to throw a billion fucking data points at me with jargon I barely understand without Googling it. Not to mention that the "middle tier" of help resources are scattered and not in one place.

Ollama's official documentation is barely helpful, llama.cpp's documentation assumes mid-level familiarity when I'm just barely past the entry level threshold.

@Dread First What GPU did you run them on?

RX 9070 XT. From my testing some months ago, 12B-14B models are basically on the upper end of what I can comfortably keep contained within my GPU.
 
To add onto my vibe coding adventures, I decided to give an AI the totally legitimate obtained source code of minecraft legacy console edition and told it to completely rewrite it to work on Linux natively. Long story short, it couldn't do it, as it used iggy and would have to reverse engineer how iggy worked, not to mention telling it to completely remove all instances of things not necessary for the windows version caused it to be fucked to begin with. Luckily, there was already a project that reverse engineered iggy, and so its back on the table for round two. While that project has linux support, I would rather have my own thing.
 
To add onto my vibe coding adventures, I decided to give an AI the totally legitimate obtained source code of minecraft legacy console edition and told it to completely rewrite it to work on Linux natively. Long story short, it couldn't do it, as it used iggy and would have to reverse engineer how iggy worked, not to mention telling it to completely remove all instances of things not necessary for the windows version caused it to be fucked to begin with. Luckily, there was already a project that reverse engineered iggy, and so its back on the table for round two. While that project has linux support, I would rather have my own thing.
I gave AI the simple task of writing me a batch script for Windows that would require one of three possible switches and a source path in order to mass-create symlinks in the current directory of all files, or all directories, or all files and directories, in the source dir.

It did it with only one minor mistake — adding one closing parenthesis too many. After deleting that, the script worked fine, and helped me successfully bork my Microsoft Store framework, so none of the Store apps work anymore, including the Defender UI.

Well, I've had plans to refresh that install, anyway. /cope
 
To add onto my vibe coding adventures, I decided to give an AI the totally legitimate obtained source code of minecraft legacy console edition and told it to completely rewrite it to work on Linux natively. Long story short, it couldn't do it, as it used iggy and would have to reverse engineer how iggy worked, not to mention telling it to completely remove all instances of things not necessary for the windows version caused it to be fucked to begin with. Luckily, there was already a project that reverse engineered iggy, and so its back on the table for round two. While that project has linux support, I would rather have my own thing.
I tried using AI to make a mod for minecraft beta consisting of just simple changes and additions and it kept generating garbage that would either not work, crash, or not launch at all. Even when giving it multiple chances and providing all the erorr messages. The same mod took me 1 hour to make with no prior minecraft modding experience.
 
Back
Top Bottom