Ronesie

  • Tuning the Home Server: Dashboards, Media, and What’s Next

    Glance / Glances

    I did a quick pass on Glance and Glances while looking for a lightweight, browser-based system dashboard. Both are capable, but Glances in particular felt more like a full monitoring suite than what I actually needed. Useful, powerful, but a bit overkill for my goal: a quick visual check on disk usage and system health.

    Dash.

    Dash ended up being the right fit. Clean UI, easy to scan, and focused on the basics. It gives me a fast sense of how the system is doing without feeling like I’m piloting a spaceship. This is the kind of “ambient awareness” tool I wanted running in a browser tab.

    Jellyfin

    Jellyfin is fully up and running. Everything plays as expected in the browser and on the TV app, and the library is locked down to avoid accidental changes. It’s reached that good point where I can stop fiddling and actually use it.

    Next Steps

    The next phase is less about servers and more about daily use:

    • Set up phones and tablets as clients (media, files, notes).
    • Decide how far to push beyond LAN-only access, or if that even makes sense.
    • Start planning storage growth and migration paths before space becomes urgent.

    For now, things are solid. The system works, it’s calm, and it’s ready to be lived with instead of constantly adjusted.

  • Home Server Series — Part 1: Nextcloud

    I’ve been slowly building a home server, not because I want to self-host everything under the sun, but because I want my data to have a calm place to live.

    This is Part 1 of what will probably be a small series. The goal here isn’t to show the “best” or most secure setup—it’s to show the first setup that actually made sense to me.

    That setup turned out to be Nextcloud, run locally, on a machine in my house, without overthinking it.

    The intention (before the tech)

    Before touching software, I had to decide what I wanted this thing to be.

    Not

    • a public cloud replacement
    • a family system (yet)
    • a perfectly hardened server

    But

    • a local-first dumping ground
    • something I could understand and undo
    • a system that didn’t punish experimentation

    That decision shaped everything that followed.

    The machine (light context)

    I’m running a small Linux box (a Minisforum mini PC) that stays on. Once it’s booted, I don’t need to stay SSH’d in. Services run whether I’m watching or not.

    SSH is for administration, not operation.

    That mental shift alone reduced a lot of friction.

    Keeping the machine boring (important early step)

    Before installing anything fun, I made sure the machine wouldn’t disappear on me.

    I disabled sleep/suspend entirely and stabilized SSH so idle sessions wouldn’t drop.

    # Prevent the system from sleeping
sudo systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target
    # Keep SSH sessions alive during idle time
sudo sed -i 's/^#\?ClientAliveInterval.*/ClientAliveInterval 60/' /etc/ssh/sshd_config
sudo sed -i 's/^#\?ClientAliveCountMax.*/ClientAliveCountMax 10/' /etc/ssh/sshd_config
sudo systemctl restart ssh

    Nothing fancy—just making the box behave like a server instead of a laptop.

    Installing Nextcloud (containerized, on purpose)

    I wanted Nextcloud to be:

    • easy to stop
    • easy to remove
    • isolated from the rest of the system

    So I ran it in containers. In my case, that ended up being Podman + podman-compose, but the concept matters more than the tool.

    The key idea:

    Nextcloud is just a web app sitting on top of storage I already own.

    Here’s the core of the compose file I used (simplified for readability):

    services:
  db:
    image: docker.io/library/mariadb:10.11
    volumes:
      - db:/var/lib/mysql

  app:
    image: docker.io/library/nextcloud:28
    ports:
      - "8080:80"
    volumes:
      - nextcloud:/var/www/html
    depends_on:
      - db

    Once running, Nextcloud was simply available at:

    http://192.168.x.x ;)

    Local network only. No exposure. No drama.

    The mental breakthrough: selective sync

    This was the moment everything clicked.

    I stopped thinking of Nextcloud as “something that syncs everywhere” and started thinking of it as:

    A server that holds everything, and clients that choose what they care about.

    On my Mac, I enabled “Choose what to sync” in the Nextcloud desktop app and only synced folders I actively work in.

    That led to a simple, human folder model.

    The folder structure that stuck

    At the top level, I landed on this:

    Misc
Working
Archive
Photos
Media
Family

    What this means in practice:

    • Misc → temporary inbox / dumping ground (synced to my Mac)
    • Working → active projects (synced)
    • Archive → finished things (server-only)
    • Photos → personal images (sync optional)
    • Media → large files, movies, future Jellyfin use
    • Family → placeholder for shared access later

    If a folder isn’t synced, it simply doesn’t appear on my laptop. It still exists on the server and is accessed through the browser when needed.

    No fear of accidental deletes. No laptop clutter.

    Access model (surprisingly simple)

    There’s no ritual when I leave and come back.

    • The Minis stays on
    • Nextcloud keeps running
    • Sync happens in the background

    When I’m home and want to see everything, I just open a browser:

    http://192.168.x.x

    That’s it. SSH and VNC are optional tools, not requirements.

    Why this feels sustainable

    Right now, this setup gives me:

    • A calm dumping ground for files
    • A lean working set on my Mac
    • A clear path toward media (Jellyfin later)
    • A structured place for family access when I’m ready

    Most importantly, nothing here feels irreversible.

    I can:

    • change folder structure
    • move storage later
    • add users later
    • even remove Nextcloud entirely if I want

    For a home server, that flexibility matters more than perfection.

    Coming up next

    Part 2 will likely be one of:

    • Media + Jellyfin (connecting to the Media folder)
    • Notes with Joplin (using Nextcloud as storage)
    • Adding family users without chaos

    For now, the system is boring and that’s exactly what I wanted.

  • Lessons Learned the Hard Way: Setting Up a Minisforum on Linux Without Ethernet

    I went into this project optimistic and ready to learn, but I also underestimated how much friction a few early decisions would introduce. I chose a Minisforum mini PC as the foundation for my home media and personal server setup, and on paper it checked all the boxes: compact, powerful, and flexible. Where things became complicated was my assumption that Wi-Fi would be a non-issue once I moved to Linux.

    I started the setup without hard-wiring the machine, which in hindsight wasn’t ideal. Once Linux was installed, the built-in Wi-Fi didn’t work, and that meant everything else depended on solving connectivity first. What followed was a lot of troubleshooting—firmware installs, reboots, and trying different approaches—before I finally accepted that Ethernet was required to move forward.

    To regain control of the system, I set up remote access using TigerVNC. Once that was working, things stabilized quickly. Being able to manage the machine remotely made the setup feel more intentional and repeatable, and it became clear that remote desktop access was going to be a core part of how I use this box long-term.

    Looking back, I would have started with the machine hard-wired from the beginning. And if I had known ahead of time that Wi-Fi support would be unreliable under Linux on this hardware, I might have reconsidered the specific model. None of this is a knock on Linux itself—just a reminder that hardware compatibility and setup order matter more than I initially gave them credit for.

    The system is now in a good place, and the experience clarified a few things for future builds: verify Linux support early, establish reliable access first, and then build upward from there.

  • Enhance

    I was trying to have a site that was barebones with copy only. But I already want to add some razzle-dazzle. The designer in me is already bumping this up in priority.

  • Local Chatbot with GPT-Neo and Hugging Face Transformers

    I’m interested in AI stuff and the chatbots are pretty fun. I have a dream of installing my own local copy to assist in some way. To be honest, I don’t know the available ways yet.

    I’m somewhat comfortable with Python because I spent the fall attempting to make a “robot”. So I thought, might as well get better at that and make some kinda chat thing.

    Setup Steps

    • Install python
    • Create a custom environment
    • Libraries to pip: argparse, transformers, torch

    Code Stuff

    Save the following in your environment and run with:

    python FILENAME.py "Whatever question you like?"
    Python Script 
    import argparse
from transformers import GPTNeoForCausalLM, GPT2Tokenizer # Add GPTNeoForCausalLM import here
import torch

def generate_text(input_text):
# Load pre-trained model and tokenizer
model_name = "EleutherAI/gpt-neo-1.3B" # Specify model name
model = GPTNeoForCausalLM.from_pretrained(model_name) # Load GPT-Neo model
tokenizer = GPT2Tokenizer.from_pretrained(model_name) # Load tokenizer for GPT-Neo

# Ensure that the pad_token_id is set to the eos_token_id for GPT-2 models
model.config.pad_token_id = model.config.eos_token_id

# Encode the input prompt
inputs = tokenizer.encode(input_text, return_tensors="pt")

# Create the attention mask (all ones, since there's no padding involved)
attention_mask = torch.ones(inputs.shape, device=inputs.device)

# Generate text from the model with adjustments for more sensible output
output = model.generate(
    inputs, 
    attention_mask=attention_mask, 
    max_length=100,  # Set max_length to a reasonable value
    num_return_sequences=1,  # Only generate one sequence
    do_sample=True,  # Enable sampling for some variety
    temperature=0.6,  # Lower temperature for more deterministic output
    top_p=0.85,  # Nucleus sampling with a smaller top_p for more focused output
    top_k=30,  # Limit to top 30 tokens for sampling
    pad_token_id=model.config.pad_token_id  # Ensure pad_token_id is set correctly
)

# Decode the output
decoded_output = tokenizer.decode(output[0], skip_special_tokens=True)

# Print the result
print(decoded_output)

if name == "main":
# Set up argument parsing
parser = argparse.ArgumentParser(description="Generate text with GPT-2 or GPT-Neo")
parser.add_argument("input", type=str, help="Input text prompt for GPT-2")

# Parse the arguments
args = parser.parse_args()

# Call the generate_text function with the user-provided input
generate_text(args.input)

    Sample Results

    Q: why is the sky blue?

    A: I’m wondering why the sky is blue. I’ve always wondered this, but I don’t know where to start. I’ve seen the sky blue in the past, but I can’t remember when. I know it was when I was a kid, but I don’t remember.

    I have a friend who is a blue-collar worker, and he says that blue is a color that is not used in the sky.

    Q: do you remember my last question?

    A: I asked you to find out if the world is ending.

    I asked you to find out if the world is ending.

    I asked you to find out if the world is ending.

    I asked you to find out if the world is ending.

    Q: do you remember my last question? think harder

    It’s a question that I’ve been asking myself for years now. I’ve been asking myself this question since I was a teenager, and I’ve been asking myself this question since I was a young man. I’ve asked myself this question a lot, and I’ve been asking myself this question a lot.

    Conclusion

    The results seemed a little un-settling so far. But from what I’ve read, this is to be expected. There are settings to adjust how varied the responses are as well as models that you have to “train”. The latter I have no idea about, but I’ll keep tinkering.

  • Hello world!

    I’m going to try to document the things I make.

    Coming soon, I hope is: Homemade Guitar Pedal, 1 Episode of a show, gpt driven site, automated plant feeder, a robot best friend, screen prints, linocuts.