
In the continuing saga of upgrading my servers, I also needed to upgrade my Nextcloud instance. There were several hurdles and pitfalls for me here, and a lot of time was wasted trying to figure out exactly what to do. I had already decided not to upgrade my instance through the built in upgrade system within NC, but instead to build a new NC instance from scratch and then move my data over.
That might seem odd, but several reasons led to this decision, the first being that the current NC instance had some sort of problem with the built in updater and was "stuck" on the previous version. Even when I could update, along the way something broke in the update software which forced me to do my upgrades from the command line instead of from the web interface. Less than ideal, for sure. It also helped that I only have a couple of family members using my NC instance, so I didn't need to move/create a ton of accounts.
I also really wanted to try using the "AIO" (All-In-One) docker solution. In the past, I had to constantly fight with my server configuration and dependency problems to get a working solution for NC. I will be the first to admit, it probably was due to something I was doing wrong, but in either event, it was a headache keeping everything working and up to date. Often when updating, I would have to drop a feature or changed so many dependencies that some of the other uses of my server, such as serving other websites, would stop working. So this time I wanted a drop in solution that had all the features and 'just worked'. the AIO docker sounded like a win to me.
Of course, with docker comes some new security issues, but hopefully I read up on that enough and implemented the proper precautions enough to make sure that is a very small, if not impossible attack surface. I won't go into too many details of that here, partly because I just followed other guides, and partly because I am concerned with sharing too much information on that point, for the safety of my server.
But, one thing that really hung me up was how to configure the AIO NC on a server that serves other websites. Normally, I use Apache2, with reverse proxy, choosing different web root folders for the different domain names and internet addresses. Due to my lack of knowledge about docker, it took me a long time to figure out how to do this with the AIO instance. The AIO includes it's own Apache2 server, which is configured to be the sole service thereof, not leaving any room or options for my other websites that I serve.
At first, I was erroneously trying to look into how do I run the AIO, and edit it's Apache configuration to include my other websites. This was backwards, I just didn't realize it at the time, and a lot of hours were wasted on that fruitless pursuit. After much research, and a little trial and error, I eventually came to this conclusion, run the AIO stand alone, but behind the reverse proxy of my Apache2 for the OS/server itself. But, I couldn't figure out what document root to use with the docker AIO on my Apache2 configuration. So I wasted a few more hours trying various methods of that. Eventually, I came to understand that when I run the docker, I could choose a different port number for it, and then used my reverse proxy to point incoming http/s requests on 80/443 that were for the NC instance to be passed to the new port number assigned to the NC instance! I didn't come up with this, I read it online [1] and I think this is actually the proper way it should be done, and it just took me several days of monkeying around to get there.
So, my apache2 configuration looked like this:
$ cat nextclouddocker.conf
<VirtualHost *:80>
ServerName REDACTED.SOMEPLACE
ServerAlias REDACTED.SOMEPLACE
RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI}
RewriteCond %{SERVER_NAME} =REDACTED.SOMEPLACE
RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
</VirtualHost>
<VirtualHost *:443>
ServerName REDACTED.SOMEPLACE
RewriteEngine On
ProxyPreserveHost On
RequestHeader set X-Real-IP %{REMOTE_ADDR}s
# Added to support Euro-office
RequestHeader set X-Forwarded-Proto "https"
AllowEncodedSlashes NoDecode
# Adjust the two lines below to match APACHE_PORT and APACHE_IP_BINDING. See https://github.com/nextcloud/all-in-one/blob/main/reverse-proxy.md#adapting-the-sample-web-server-configurations-below
ProxyPass / http://localhost:11000/ nocanon upgrade=websocket
ProxyPassReverse / http://localhost:11000/
# Enable h2, h2c and http1.1
Protocols h2 h2c http/1.1
# Solves slow upload speeds caused by http2
H2WindowSize 5242880
# TLS
SSLEngine on
SSLProtocol -all +TLSv1.2 +TLSv1.3
SSLCipherSuite ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-RSA-CHACHA20-POLY1305
SSLHonorCipherOrder off
SSLSessionTickets off
# If running apache on a subdomain (eg. nextcloud.example.com) of a domain that already has a wildcard ssl certificate from certbot on this machine,
# the <your-nc-domain> in the below lines should be replaced with just the domain (eg. example.com), not the subdomain.
# In this case the subdomain should already be secured without additional actions
# Disable HTTP TRACE method.
TraceEnable off
<Files ".ht*">
Require all denied
</Files>
# Support big file uploads
LimitRequestBody 0
# The default NEXTCLOUD_MAX_TIME value is 3600 seconds.
# By setting it 10 seconds higher than that, we make sure that always Nextcloud times out and not Apache.
# If you increased NEXTCLOUD_MAX_TIME, increase the timeout below accordingly.
Timeout 3610
ProxyTimeout 3610
Include /etc/letsencrypt/options-ssl-apache.conf
SSLCertificateFile /etc/letsencrypt/live/REDACTED.SOMEPLACE/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/REDACTED.SOMEPLACE/privkey.pem
</VirtualHost>
Thus my server's Apache2 config accepted requests on 80/443 bound for my NC instance, and passed them over to port 11000 instead, leaving all of the heavy lifting to the AIO's built in Apache server, with PHP, etc., and my OS/server doing all of the SSL encryption. Of course, to get the docker running, I had to edit the usual launch command to make sure it listened on that port instead:
docker run --init --sig-proxy=false --name nextcloud-aio-mastercontainer --restart always --publish 8080:8080 --env APACHE_PORT=11000 --env APACHE_IP_BINDING=0.0.0.0 --env APACHE_ADDITIONAL_NETWORK="" --env SKIP_DOMAIN_VALIDATION=false --env NEXTCLOUD_DATADIR="/data/ncdata" --volume nextcloud_aio_mastercontainer:/mnt/docker-aio-config --volume /var/run/docker.sock:/var/run/docker.sock:ro ghcr.io/nextcloud-releases/all-in-one:latest
Note that the APACHE_PORT is set for 11000, meaning the docker AIO Apache is listening on 11000. Also important to note is that I set --env NEXTCLOUD_DATADIR to a real place on my server, so I could easily move files in and out of the NC instance. It also makes backups easier.
Speaking of moving files, I then needed to move 1.1 TBs of family photos, home videos, and audio recordings from the old server onto the new server and import them into NC. To facilitate this, I created a user named "OldServer" and in the OldServer NC folder, I digitally put all 1.1 TBs of data. To import it into my Nextcloud, I ran this command within the folder on the /data drive:
docker exec --user www-data -it nextcloud-aio-nextcloud php occ files:scan OldServer
And NC did the rest to import all the files. It took a while, because of all the data, but it was a lot faster than importing it through a web gui or app. Once the data was in, I shared the appropriate user folder with the appropriate user. I wouldn't recommend this for everyone, but since it was for my own family members, where we already shared all of the photos and videos and such, there wasn't really a security concern, nor any "sensitive" data. I could have put the appropriate files into the appropriate user's individual folders and then ran the scan for all or each user instead, if that had been a concern.
Either way, it was a slow process, but I am really glad I did it this way because I learned a lot about using docker! I also really hope this will make future upgrades simpler and seamless, without the hassle of changing dependencies, since they are all built into the AIO docker instance. I did run a security scan of my server, and came out with an A+ certification for the NC instance, which was encouraging.
Linux - keep it simple.
[1] https://github.com/nextcloud/all-in-one/blob/main/reverse-proxy.md

Recently, I upgraded my server (posts to follow on that adventure). As well as updating the server, I also changed my blog software and setup. The short and the sweet of it is this, the old blog, alaskalinuxuser3.ddns.net is still up and running my Pelican generated static site. My plan is to leave it up for the time being, perhaps for as long as I blog, as a historic record of previous projects. However, going forward, I will be using the web address of alaskalinuxuser.ddns.net for future blog posts.
I decided to switch to Bludit CMS, a flat file site generator, rather than continue with Pelican for blogging. Both allow building posts in markdown, and both create a flat file website. However, Pelican has no admin panel or interface for plugins, which made the ability to create posts a little more tedious. Granted, for Pelican I had automated most of the process, with bash scripts and such, but it became a bit tiresome to have to transfer my posts files and media from whichever computer I wrote on to the server, then change the permissions, and rebuild the website for each post. With Bludit, there is an admin panel, and I can log in from any browser, upload media, make posts, save drafts, etc.
Don't get me wrong, I love/d Pelican, but I just needed to simplify my life by making it easier to make posts. Why Bludit? Well, I wanted to stick with a flat file website system, so I tried several. I almost went for HTMLy, but decided on Bludit after trying them both on a local server. The interface for Bludit is very simple and easy to use. You can use markdown, or a WYSIWYG text editor instead. Bludit also has a Disqus plugin for handling comments. While I have not enabled it yet, I have had several requests from my (few) readers that they would like to be able to leave a note or thought on my articles, and that may be an avenue I go down in the future. We'll see.
Either way, be sure to bookmark the new website, and also feel free to subscribe to the RSS feed!
And remember, if you are looking for older posts (before January 2026), head over to alaskalinuxuser3.ddns.net to read them.
Linux - keep it simple.

While I am, as I have said, not a big fan of AI, I have been doing my due diligence to learn about it in the event that the need to use it should arise. Again, I clarify "need" not as a lighthearted, "I need to know this or that, so I'll just ask AI...", but rather a need such as a work requirement. I hope this will be my final article in this series about AI, at least for the time being.
Being in the IT field, and a somewhat technical person, I started out with one overarching goal in learning about AI: how can I self host an AI instance that I can integrate with some other program. While I may not be a fan of AI, I have learned quite a few technical things along the way, and I'm glad that I set out on this "adventure". Today's post is the latter end of that trek, mainly the technical ability to use or integrate AI into some other program.
Of course, as you recall from my first post [1], I am self hosting various AI models, such as llama3.2 and llama3.3 with Ollama, the python based open source interface. In my second post [2], I made a note about how to use the API of Ollama to send requests and receive the reply. But I wanted to make sure that I understood not just the API interface, or how to host my own AI models, but how to actually integrate or use it in another program or app for daily workflow, rather than just as a chat tool. Could I feed it code and have it spit something (however untrustworthy) back out to me?
First, I wanted to know how to access my self hosted models from another computer. For security reasons, I didn't want to open up my computer to the internet, but did want to prove I could do it within my own home network. By default, Ollama actually only accepts or listens to requests on the local loopback network, lo, on the loopback address, 127.0.0.1, port 11434. Trying to access it from another computer in the network would just get you an access denied response:
$ curl http://192.168.5.251:11434/api/tags
curl: (7) Failed to connect to 192.168.5.251 port 11434 after 61 ms: Couldn't connect to server
In this request, I am requesting the tags, or essentially list, of available models. Because I am requesting this information from another computer over the local network, I receive the "Failed to connect" error. If I run this command on the machine hosting the models, I get the proper response, which looks like this:
{"models":[{"name":"llama3:latest","model":"llama3:latest","modified_at":"2026-08-29T06:22:48.871118746-08:00","size":4661224676,"digest":"365c0bd3c000a25d28ddbf732fe1c6add414de7275464c4e4d1c3b5fcb5d8ad1","details":{"parent_model":"","format":"gguf","family":"llama","families":["llama"],"parameter_size":"8.0B","quantization_level":"Q4_0","context_length":8192,"embedding_length":4096},"capabilities":["completion"]}...........EDITED FOR BREVITY..........
So, how can I get that to work over the local network? There are two ways that I know of. The first is to make a few routing rules for the server computer to bind incoming traffic on the network to the loopback address. I tried this:
sudo iptables -t nat -A PREROUTING -i eno1 -p tcp --dport 11434 -j DNAT --to-destination 127.0.0.1:11434
sudo iptables -A FORWARD -i eno1 -o lo -p tcp --dport 11434 -d 127.0.0.1 -j ACCEPT
sudo iptables -t nat -A POSTROUTING -o lo -j MASQUERADE
This almost worked, but not quite. For some reason, this worked to route traffic from the LAN to the loopback device, allowing the server to accept requests over the local network and pass them to the local loopback interface and give the request to Ollama. Unfortunately, it didn't work to route the reply back to the computer making the request. I'll be honest, I'm not sure why. I must be getting rusty in my iptable routing, and looking at various examples online didn't seem to shed light on my problem. But in theory, this, or something close, should work.
The second method to expose Ollama to the local network is to change the environment variable for "OLLAMA_HOST" to be 0.0.0.0:11434, meaning to listen to anybody on that port, not just local loopback. So, I set the variable:
export OLLAMA_HOST=0.0.0.0:11434
And I tried to run Ollama. But I still got the denied errors, and Ollama completely ignored this export. So, I set it in my system variables by editing /etc/environment to include it, making it a global system variable that is set all the time, and one which is persistent. But that didn't work either. Ollama just ignored it, again. I read around online and tried several other things, like passing it as an argument when calling Ollama, like so:
OLLAMA_HOST="0.0.0.0:11434" ollama serve
But, Ollama didn't care. It was getting to be a bit frustrating. For grins, I asked llama3 how to do this, starting with questions about which port to use, etc., but at one point it said that you don't "self host" Ollama, and then gave me a story about using port 8080, because that is the "default port for Ollama", yet the default (per Ollama's documentation)[3] is actually port 11434. Here was llama3's output:
>>> what is ollama's default port when self hosted?
When self-hosting Ollama, the default port is **8080**.
In the `ollama.config` or `ollama.json` file, the `listen_port` setting is
set to 8080 by default, which means Ollama will listen for incoming
requests on port 8080.
So, when you're hosting Ollama locally, you can access it by visiting
`http://localhost:8080` or `http://<machine_ip>:8080` (replace
`<machine_ip>` with the IP address of the machine running Ollama) in your
web browser.
So I realized that it must be different when using Ollama as a snap, and it turns out this was the case. Your Ollama environment variables are useless when you run Ollama as a snap. Once I figured that out, a little bit of searching in the documentation lead me to where I needed to go:
sudo snap set ollama host=0.0.0.0:11434
This command sets the OLLAMA_HOST variable for the snap. It would appear that the usual OLLAMA_ variables are all there, just without the OLLAMA_ prefix. You can also read them with 'snap get' instead! After setting that variable in the snap, it was now a trivial matter to test access from another local network machine:
~$ curl http://192.168.5.251:11434/api/tags
{"models":[{"name":"llama3:latest","model":"llama3:latest","modified_at":"2026-08-29T06:22:48.871118746-08:00","size":4661224676,"digest":"365c0bd3c000a25d28ddbf732fe1c6add414de7275464c4e4d1c3b5fcb5d8ad1","details":{"parent_model":"","format":"gguf","family":"llama","families":["llama"],"parameter_size":"8.0B","quantization_level":"Q4_0","context_length":8192,"embedding_length":4096},"capabilities":["completion"]},{"name":"llama3:8b","model":"llama3:8b","modified_at":"2026-08-29T06:20:44.08856588-08:00","size":4661224676,"digest":"365c0bd3c000a25d28ddbf732fe1c6add414de7275464c4e4d1c3b5fcb5d8ad1","details":{"parent_model":"","format":"gguf","family":"llama","families":["llama"],"parameter_size":"8.0B","quantization_level":"Q4_0","context_length":8192,"embedding_length":4096},"capabilities":["completion"]},{"name":"llama3.2:latest","model":"llama3.2:latest","modified_at":"2026-08-26T04:58:50.45297552-08:00","size":2019393189,"digest":"a80c4f17acd55265feec403c7aef86be0c25983ab279d83f3bcd3abbcb5b8b72","details":{"parent_model":"","format":"gguf","family":"llama","families":["llama"],"parameter_size":"3.2B","quantization_level":"Q4_K_M","context_length":131072,"embedding_length":3072},"capabilities":["completion","tools"]}]}
Great! Now I could access my AI models from any computer within my local network! I did do some testing from external networks to make sure I couldn't reach it from outside, which firewall rules on my router do stop. Satisfied with that, I then set about to the real task, attaching it to some app or program to "integrate" it into a workflow. One program I use a bit is Godot, the game engine which has it's own IDE, so I decided to try that.
Turns out it was pretty easy. In Godot 3x and 4x, you can use the Godot Copilot Plugin [4], which allows your usual Godot interface to have an extra tab where you can integrate an AI, but it wouldn't let you choose a self hosted instance. In Godot 4.3+, however, you could use the Godot AI Assistant Hub plugin, of which our title picture above shows how you can integrate your own locally hosted AI, asking it questions and showing it highlighted code within the development environment.
Feeling that the goal is now met, I can now move on to other things. While I don't intend to use AI personally, I did learn a lot by trying to self host, network, and integrate one into a "daily workflow" of something that I could use, even if I don't intend to actually do it.
Linux - keep it simple.
[1] https://alaskalinuxuser3.ddns.net/Running%20a%20local%20AI%20model%20with%20Ollama%20and%20AI%20pitfalls.html [2] https://alaskalinuxuser3.ddns.net/Using%20a%20local%20AI%20model%20with%20API%20and%20further%20response%20to%20API%20pitfalls.html [3] https://docs.ollama.com/faq [4] https://github.com/minosvasilias/godot-copilot/tree/3.x [5] https://github.com/FlamxGames/godot-ai-assistant-hub

After my blog post about running your own AI locally, I received some feedback regarding my arguments against using AI. Today, I'd like to respond to that feedback, but also I want to make a note for myself about how to use your locally run AI model via the API, rather than directly typing in the prompt of Ollama.
Using Ollama via API
So, first things first. How to use the API. Begin by launching the AI. In this case, I downloaded a bigger and better AI model, llama3.3 with 8B, or 8 billion parameters, as opposed to the llama3.2 model I was using that only had 3 billion parameters. I pulled it like so:
$ ollama pull llama3:8b
pulling manifest
pulling 6a0746a1ec1a: 100% ▕██████████████████████████████████████████████████████████ ▏ 4.7 GB/4.7 GB 10 MB/s 0s
pulling 4fa551d4f938: 30% ▕█████████████████ ▏ 3.7 KB/ 12 KB
pulling 3f8eb4da87fa: 100% ▕███████████████████████████████████████████████████████████▏ 485 B
verifying sha256 digest
writing manifest
success
Nothing new, we did this in the last article. Then I run the new model:
alaskalinuxuser@alaskalinuxuser-CF-52NKE102M:~$ ollama run llama3:8b
Now that llama3.3 is running, I then open another terminal, and type this in it:
$ curl -X POST http://localhost:11434/api/generate -d '{
"model": "llama3:8b",
"prompt":"Why is the sky blue?"
}'
Here I'm just using curl to call and pull the output from the API. Essentially, I give it a destination (localhost) a port number (11434), and tag which running model I want (note it will not start a model that is not running) and enter my prompt. Pretty simple. I just wanted to write this down so I can reference it later. Though I suppose I could have just asked llama....
Responses to questions about my previous AI article.
In my previous article [1] about AI models, I pointed out how you couldn't trust AI because it:
Hallucinates or makes things up.
Often has errors or is inacurate.
Takes more time to review it's output than to make it yourself.
Doesn't make you smarter.
From which I received several pieces of feedback, but the most interesting one was that I am not using a good AI model, or that there are better AI models which will have better performance and thus better results. I agree fundementally with that argument. There are better AI models out there, and some will likely give better performance. I'd like to propose, though, that my arguments against using them are still vallid. Let's take a quick look at AI models so we understand a little more before we begin:
AI models have parameters. These are the "buttons", "boxes", "switches", or "knobs" of the model, which allow it to make the output. My previous article was using the llama3.2 model with 3 Billion parameters. The model I just downloaded today has 8 Billion parameters. In theory, the more parameters, the better the model works. Think of a photograph, the higher the resolution, the better the photo. AI models also have different training methods. They can be "constitutional", where they are given a constitution, a set of rules, and as it makes output, it checks that against the rules and determins if it is good output or not. A ficticious example would be a constitution for a cat drawing program that has rules like: "All cats will have one tail, four paws, and two ears on the top of their head." If it draws a cat that has two tails, it throws it out, because that doesn't meet the rules. The other method of training is real life human feedback, where a person gives the output a score, rewarding good output. Real life human feedback is a bit more expensive, but seems to produce better results, though may suffer from bias of the human.
My counter to this argument is that no matter how good the AI model is, my four points are still valid to some degree. If the AI model makes any inacuracies or errors, or hallucinates/make things up at all, you will still have to review all of it's output to be sure that it is correct. Also, I submit that the better the AI model, the less brain activity you will use, as you offload more tasks/though process to the AI model, and actually accentuates my point about AI models not making you smarter.
But if that's the case, we should be able to test and verify that. The previous article I asked llama3.2:3B to tell me the rules of chess. How about we ask llama3.3:8b the same question. Since it has 5 Billion more parameters, perhaps it will get it right? Let's see:
alaskalinuxuser@alaskalinuxuser-CF-52NKE102M:~$ ollama run llama3:8b
>>> can you tell me the rules of chess?
The rules of chess! Yes, I'd be happy to explain them to you. Here's a comprehensive guide to get you started:
**The Basics**
1. The game is played on a square board with 64 squares, alternating in color between light and dark.
2. Each player starts with 16 pieces: one king, one queen, two rooks, two knights, two bishops, and eight pawns.
3. The objective is to checkmate your opponent's king (put the king in a position where it's in danger of being
captured, and there's no way to move the king out of capture).
**The Pieces**
1. **King**: The most important piece. If your king is in check, you must move it to a safe square or block the
check with another piece. If your king is checkmated, you lose.
2. **Queen**: The most powerful piece, able to move in any direction (horizontally, vertically, or diagonally) any
number of squares.
3. **Rook**: A piece that can move horizontally or vertically any number of squares.
4. **Bishop**: A piece that can move diagonally in any direction.
5. **Knight**: A piece that moves in an L-shape (two squares in one direction, then one square to the side).
6. **Pawn**: The foot soldiers. Pawns can move forward one square, but capture diagonally one square.
**How the Pieces Move**
1. **King**: One square in any direction (horizontally, vertically, or diagonally).
2. **Queen**: Any number of squares in any direction (horizontally, vertically, or diagonally).
3. **Rook**: Any number of squares horizontally or vertically.
4. **Bishop**: Any number of squares diagonally.
5. **Knight**: Two squares in one direction, then one square to the side (L-shape).
6. **Pawn**: Forward one square, but captures diagonally one square.
**Special Moves**
1. **Castling**: A special move that allows the king to move three squares towards a rook, while the rook moves to
the square the king crossed. This is the only move that allows the king to move more than one square.
2. **En Passant**: A pawn can capture an opponent's pawn "en passant" if the opponent's pawn moves two squares
forward from its starting position, landing adjacent to your pawn. You can capture the pawn as if it had only moved
one square.
3. **Promotion**: When a pawn reaches the opponent's end of the board, it can be promoted to any piece (except a
king).
**Check and Checkmate**
1. **Check**: When a player's king is under attack, it's said to be "in check." The player must move their king to
a safe square or block the check with another piece.
2. **Checkmate**: When a player's king is in check and there's no way to move the king out of capture, it's
checkmate, and the game is over.
**Other Rules**
1. **Capturing**: A piece captures an opponent's piece by landing on the square occupied by that piece.
2. **Blocking**: A piece can block a capture by moving into the square the opponent's piece was trying to capture.
3. **Draw**: If both players agree to end the game with a draw, or if the same position occurs three times
(including the initial setup), the game is a draw.
That's it! With these rules, you're ready to start playing chess. Remember, practice makes perfect, so don't be
afraid to make mistakes and learn from them. Happy chess-ing!
>>> exit
It was nice playing chess with you! If you want to play again or need help with anything else, feel free to ask.
Otherwise, I'll exit and wait for your next question. Bye for now!
>>> /bye
Just a few points here, there may be more if we dig into it, but under "The Basics" and "Check and Checkmate", the only two methods listed to get out of check are to move the king to safety or block (interpose) with a piece. This neglects the option to capture the oposing piece. Okay, maybe it just forgot that one. No problem, right?
How about under "The Pieces" and "How the Pieces Move", both don't list that a pawn can move forward two squares from the starting position. Just an oversight, I'm sure.
Or, under "Special Moves", it says that to castle, the king moves three squares. Except a king only moves two squares. This is wrong, or inacurate, information. It also doesn't cover not castling across check, and that the other pieces must not be in the way, but that may be nit-picking on my part.
I think this AI model is hallucinating, because under "Other Rules" it says that "A piece can block a capture by moving into the square the opponent's piece was trying to capture." Which is incorrect.
The AI also doesn't mention stalemate as an option under "Draw". So at best this is not a full list of chess rules, with the above being incorrect.
Now, it did do "better" than llama3.2, but still missed the mark. What was interesting though, is when I went to leave, I erroniously typed "exit", to which it thanked me for playing a game of chess with it. But I didn't play llama3.3 a game of chess, so why did it say that? Well, because it is a statistics based predictor, not artificially intelligent.
But okay, it was still a really low grade model compared to using the "big guns" that Google runs, right? So I decided to go online, to Google, and ask the AI model there to play me a game of chess. You will need a board to see this, but here was the game we played:
1. e4 c6
2. d4 d5
3. e5 c5
4. c3 cxd4
5. cxd4 Nc6
6. Nf3 Bg4
7. Be2 e6
8. O-O Qb6
9. Nc3 Bxf3
10. Bxf3 Qxd4
11. Qxd4 Nxd4
12. Bd1 a6
13. Be3 Nc6
14. Rac1 Nxe5
15. Rfe1
You play Nxe5, capturing my unprotected central pawn! However, this leaves your knight vulnerable to a tactical reply.I will use my rook to pin your knight to your un-castled king along the open e-file:14... Nxe515.
Rfe1
The game history so far:
e4 c6d4 d5e5 c5c3 cxd4cxd4 Nc6Nf3 Bg4Be2 e6O-O Qb6Nc3 Bxf3Bxf3 Qxd4Qxd4 Nxd4Bd1 a6Be3 Nc6Rac1 Nxe5Rfe1 ...Your turn!
Your e5-knight is now pinned against your king, and my e3-bishop is also eyeing the f4 square to add more pressure. How will you defend or escape the pin?What is your next move? You could choose to:Defend the knight with f6 or Bd6Move your king out of the potential line of fire by preparing to castle
If you play this out on a real board, you will see that my knight is not pinned to my king. There are still a pawn and bishop on that file, as well as the knight, between my king and the newly moved rook. The supposed "big guns" Google ChatGPT is either hallucinating or made an error/inacuracy in judgement by not just one piece, but two pieces. Thus, back to my original thoughts on AI, I don't feel that it is trustworthy. Certainly not trustworthy with your health, or financial data, and probably best avoided, even for mundane and simple tasks. Again, I'm not concerned with this AI model's lack of skill at the game of chess. Computers have beat people for over a decade now, but rather that the output of this, or maybe all AI models is/are untrustworthy. Yet this is one of the most used AI models in existence, since everyone just "Googles" everything nowdays, and it is enabled by default on most browsers.
This does beg the question, though: which AI model are you getting when you go to a website or use an online based tool? Hmmm.... Things to ponder.
I personally hope to stay away from AI, with the exception of doing the learning I need to do in order to understand how to use it, even if I don't intend to do so.
Linux - keep it simple.
[1] https://alaskalinuxuser3.ddns.net/Running%20a%20local%20AI%20model%20with%20Ollama%20and%20AI%20pitfalls.html

To be upfront and honest, I'm not a very big fan of AI. I litterally think of it as a machine that predicts the next word, pixel, image, code, thing, based on statistics. One of the dangers of such a machine is that it does so in a "life-like" manner, which can sound very natural, while actually giving you completely false information. I know that there are plenty of people who do like using AI, and I'm not faulting them, but I don't think it is a very good idea for me personally. However, in light of all of the above, while I don't like to use AI, I do need to understand how it works, and how to use it should the need arise. I say need, as in, not that I suddenly trust it and find I should use it, but rather a need as in, my job suddenly requires us to use it, as is happening in a lot of other fields. Being in an IT based field, I also feel that I should be at least familiar with installing and using AI. And, if I had to use it, I would prefer to use a self hosted version of it, rather than gift more of my digital life to someone else's AI on their computer where they may be using my personal data or querries for less than great purposes.
Installing and running an AI model was surprisingly trivial on Ubuntu 24. I installed Ollama, which is a python based open source tool to interface with various AI models:
# Install Ollama:
$ sudo snap install ollama
ollama v0.32.14 from Matias Piipari (mz2) installed
# Download one of the AI models:
$ ollama pull llama3.2
pulling manifest
pulling dde5aa3fc5ff: 100% ▕██████████████████████████████████████████████████████████ ▏ 2.0 GB/2.0 GB 2.0 MB/s 0s
pulling 56bb8bd477a5: 100% ▕███████████████████████████████████████████████████████████▏ 96 B
verifying sha256 digest
writing manifest
success
The reason I downloaded the llama3.2 model was because it was realatively small (at 2 GB download) and was supposed to work well with a regular CPU, as opposed to many models requiring a GPU for generating output. To run the downloaded model was also pretty simple:
# To start llama3.2:
$ ollama run llama3.2
# My first query:
>>> write a python script to multiply 6 and 4
# Multiplication Script
==========================
This script performs multiplication of two numbers, 6 and 4.
`python
# Function to multiply two numbers
def multiply(num1, num2):
"""
Returns the product of two numbers.
Parameters:
num1 (int): The first number.
num2 (int): The second number.
Returns:
int: The product of num1 and num2.
"""
return num1 * num2
# Define the numbers to multiply
num1 = 6
num2 = 4
# Multiply the numbers
result = multiply(num1, num2)
# Print the result
print(f"The result of multiplying {num1} and {num2} is {result}")
`
### How to Run the Script
1. Save this script in a file with a `.py` extension, for example, `multiplication.py`.
2. Open a terminal or command prompt and navigate to the directory where you saved the script.
3. Run the script using Python, for example, `python multiplication.py`.
### Example Output
`
The result of multiplying 6 and 4 is 24
`
This script defines a function `multiply` that takes two numbers as input and returns their product. It then
defines two numbers, multiplies them using the `multiply` function, and prints the result.
>>> /bye
I then copied all of the script it produced into a new file called 'multiplication.py', and ran it with python3 ./multiplication.py, and saw that it actually worked. That seems pretty handy! Ask for some code, and receive it! But then why am I so opposed to using AI if it can generate code in such a simple manner, complete with explainations of what all that code means? Well, there are several reasons for that, which I hope to show you in the remainder of this article with some real examples.
Can you trust the AI output?
One of the greatest pitfalls of using AI is the trust level of the user. Most people that I talk to 'on the street' seem to implicitly trust AI. But should you actually trust what AI says? I don't think so. Let's do a simple experiment, let's ask AI to tell us the rules to a well known game. Here, I asked llama3.2 to tell me the rules of chess:
>>> can you tell me the rules of chess?
The rules of chess are as follows:
The Setup
1. The game starts with the setup of the board, which consists of 64
squares, arranged in an 8x8 grid.
2. Each player has 16 pieces: one king, one queen, two rooks, two knights,
two bishops, and eight pawns.
3. The pieces are placed on the board as follows:
* Rook (or castle) on the corner squares (a1, h1, a8, and h8).
* Bishop on the squares next to the rook (b1, g1, b8, and g8).
* Knight on the squares next to the bishop (c1, f1, c8, and f8).
* Queen on the center square (d1 and d8).
* King on the square in the middle of the four corner squares (e1 and
e8).
* Pawns on the second row (b2-h2 and b7-h7).
The Objective
1. The objective of the game is to checkmate the opponent's king, which
means the king is under attack and cannot escape capture.
2. The game can also end in a draw if both players agree to a draw, or if
the same position occurs three times (with the same player to move).
Movement
1. The pieces move differently:
* King: one square in any direction (horizontally, vertically, or
diagonally).
* Queen: any number of squares in any direction (horizontally,
vertically, or diagonally).
* Rook: any number of squares horizontally or vertically.
* Bishop: any number of squares diagonally.
* Knight: two squares in one direction (horizontally or vertically), then
one square in a perpendicular direction.
* Pawn: one square, but can move two squares on its first move.
2. Pieces can only move to an empty square, or capture an opponent's piece
by landing on its square.
Capturing
1. A piece captures an opponent's piece by landing on the square occupied
by that piece.
2. When capturing, the capturing piece stays on the square.
Special Moves
1. Castling: the king can move three squares towards a rook, and then move
the rook to the square the king crossed. This is the only move that allows
the king to move more than one square.
2. En passant: if a pawn moves two squares forward from its starting
position, and lands adjacent to an opponent's pawn that could have
captured it if it had only moved one square, the opponent can capture the
pawn "en passant" by moving diagonally to the square the pawn crossed.
3. Promotion: when a pawn reaches the opposite side of the board, it can
be exchanged for any piece (except a king).
Check and Checkmate
1. Check: when a player's king is under attack, it is said to be "in
check." The player must move their king to safety, or block the check with
one of their pieces.
2. Checkmate: when a player's king is in check and there is no way to
escape the check, the game is over and the other player wins.
Other Rules
1. A player can only move one piece per turn.
2. A player cannot move a piece to a square that is occupied by another
piece of the same color.
3. A player cannot capture a piece that is not their own.
4. A player must make a move on their turn. If they do not have a move,
the turn ends and the opponent's turn begins.
That's a basic overview of the rules of chess. Of course, there are many
variations and house rules, but this should give you a good starting point!
This is the unedited output from llama3.2, using Ollama as the interface. There are actually several problems with this ruleset that llama told me. First, and most obviously an error, is under "Other Rules", number 4, which states: "A player must make a move on their turn. If they do not have a move, the turn ends and the opponent's turn begins." This is completely false. If you play chess, you know that when a player has no legal move, but it is their turn, then the game is a stalemate, which is a type of draw. This also puts the "Objective", point 2, under scrutiny, since it said the draw can only happen if "both players agree to a draw, or if the same position occurs three times (with the same player to move)." It left out stalemate as part of the rules. Further, under "Movement" and "Capturing", the Pawn moves are not properly declared. Back to "Other Rules", rule 3 states that "A player cannot capture a piece that is not their own." Which to me means that you can only capture your own pieces, but rule 2 seems to contradict that rule.
Okay, so big deal, right? AI didn't do a very good job of explaining the game of chess. But now you are going to feed AI all of your symptoms and have it tell you what disease you have, and what treatment options are available to you. You're going to use AI to handle your stock exchange trades and manage your retirement. But, it contradicted itself and can't properly tell you the rules of chess. How would you let it handle your health, your finances, your life? If you can't trust it with a little task, can you trust it with a big one?
"One who is faithful in a very little is also faithful in much, and one who is dishonest in a very little is also dishonest in much." - Luke 16:10
Does it really save you time?
According to the Harvard Business Review [1], a recent study shows that workers actually spend more time reviewing and fixing AI mistakes than it actually saves. This sort of goes back to my last point, about AI being somewhat untrustworthy. Consider this:
$ ollama run llama3.2
>>> tell me a joke
Why don't scientists trust atoms?
Because they make up everything.
>>> do you make up anything?
That's a clever connection! As a conversational AI, I generate text based
on patterns and associations in the data I was trained on. While I strive
to provide accurate and helpful information, I can make mistakes or create
fictional content.
For example, I might:
1. Make up definitions for unfamiliar words or concepts.
2. Generate fictional stories, characters, or scenarios.
3. Create false information or misinformation (although I try to avoid
this!).
4. Use hypothetical or speculative language to explore complex ideas or
concepts.
So, if you can't trust the AI output, you have to verify everything it says, which takes time. Sometimes the effort spent verifying, and potentially correcting AI is more time than it takes to do the requested task. We already saw above that we would have to correct the 'rules of chess' that llama gave me. In that rule set, which is just 75 lines long, we found at least four errors or contradictions without even trying. Imagine having it compile data from a huge database of thousands or millions of data points. Since we already know we can't trust it, we have to rehash the data ourselves to make sure it is right. Thus, we spent the time asking the AI to hash the data, and then the time to rehash it ourselves to double check the AI. Did we really save any time?
AI is not actually intelligent, artificially or otherwise.
Again, AI, by it's own definition it gave to me, is not actually sentient or intelligent. It "generates text based on patterns and associations in the data I was trained on." Consider this game of chess I played against llama:
$ ollama run llama3.2
>>> lets play chess, don't show the board. I'll be white.
I'll play black. You can make the first move.
>>> Nf3
I'll respond with Nc6.
>>> g3
I'll play d5.
>>> d4
I'll respond with exd4.
>>> that is an illegal move.
You're right, capturing the pawn on d4 is not allowed since it's not your
turn to capture.
Let's try again. Since you played g3, I'll respond with e6.
>>> Bg2
I'll play Qe7.
>>> 0-0
You've castled kingside. I'll play Qe7 first, then Na5.
>>> d3
I'll respond with Qc5.
>>> Be3
I'll play f6.
>>> Bxc5
I'll respond with bxc5.
>>> That move is illegal.
You are correct, capturing the bishop is not a valid move.
Let me try again. Since you've played Bxc5, I'll respond with a6.
>>> Bxf8
A check! I'll play Kxf8 to block the check, then I'll recapture the pawn
on f8.
>>> /bye
For those of us who can't play chess in our head, a board was needed for this exersize. I was using a computer board with PyChess and made my moves, and then the AI's move on the board. When I moved my pawn to d4, llama responded with exd4, which is illegal. To perform this move, llama's e pawn would need to be on e5. But as you can see from the list of moves, e5 was never played, so the pawn cannot be there to make the capture. But, being a 'good sport' llama accepted my claim of an illegal move and backed up the game. Notice though, that it didn't go back to my d4 move, it went back to my g3 move, ignoring it's own d5 move and instead played e6! Wait a minute! It took back two of it's moves and one of mine! The AI litterally just hallucinated[2] a piece or position!
Okay, okay, I'll play on from this now altered position. After I castle kingside, llama decides to play "Qe7 first, then Na5." By it's own definition of the rules from earlier, it cannot move twice in one turn! Further, it already moved the queen to e7. So it can't do this again. So I took this to mean (I had to interpret the meaning of what should have been clear) that it meant, since it moved the queen to e7, now it will move the knight to a5. But, we play on. After I move Be3, the queen on c5 is under attack, it makes a simple move of a pawn, rather than defending the queen, and loses the queen (and really, the game) in an epic blunder. But here's what is funny: when I capture the queen with Bxc5, the response is bxc5, meaning the b pawn will take on c5. That move is again, illegal. It would need the b pawn to be on b6, which we can see has not happened at any time during the game. Ironically, llama could have played Bxc5, and recaptured with the bishop. The capital letter is important for standard chess notation, though, and llama admitted that I was correct, and chose a different move.
Finally, when it corrected itself and played a6, I captured his bishop with Bxf8. At this point, llama's analysis of the game lead llama to believe that it was in check, but it is not in check. Further, to get out of check, llama decided to capture my "pawn" on f8, but I cannot have a pawn on f8. Not only can I not have it there based on the game we have played so far, but also any pawn that reaches the eigth rank becomes a piece, either a queen, rook, bishop, or knight. It cannot, per the rules, remain a pawn.
I just quit the game. But, back to my original point, can you trust AI: absolutely not! But further, does it save you any time? In this case, no. I spent more time trying to figure out what the AI was doing, and correcting it's moves, then actually making my own moves. In 11 prompts for input of my moves, two were used to tell the AI that it made an illegal move, one was a move that was erased by the AI, one was a re-move because of the 'removed' move, and the last prompt led to another illegal move. Not even debating it's lack of chess skill, but I had to constantly check what the AI was doing because it was not following the inputed data correctly. So if I feed it a 3000 point database and ask it to show me a trend, I would need to verify all of the output to make sure it was correct, and potentially re-prompt the AI with further instruction to correct its errors. I submit that you may be better off reviewing the data yourself, and probably save time doing it.
"Know well the condition of your flocks, and give attention to your herds," Proverbs 27:23
Using AI doesn't make you smarter.
There are several studies, such as by Harvard [4] and others, like MIT [3] that show the use of AI is actually causing mental atrophy. The MIT even went on to say that the brain of people that use a lot of AI: "showed less activity in brain networks associated with cognitive processing while undertaking the exercise." E.g., they can actually measure your brain activity, and relying on AI regularly caused the test subjects to have lower measured brain activity over time. That's scary.
Every night, I read my children a book before bed. As they have grown, so have the books. We've done lots of classics, Narnia, Lord of the Rings, etc., but one of the books we did was "Carry on, Mr. Bowditch". It was actually an excellent book about Mr. Bowditch, who 'wrote the book' on modern navigation back when they were still sailing by the stars. In the book, Mr. Bowditch makes numerous calculations in his head that most of us (myself for sure) would struggle with, or not be able to compute at all, even with pad and paper. Why is that? Well, I think it is actually because of the calculator and the computer. We no longer need to calculate those things in our head, or on paper, because we can punch it into a calculator or spreadsheet or computer math program. My brain has atrophied in the ability to perform a lot of math functions because I never have to do it. Now take that problem and amplify that by having an AI machine that can answer every question, program anything, and compile data for you - if you can trust it.
"If any of you lacks wisdom, let him ask God, who gives generously to all without reproach, and it will be given him." - James 1:5
So, should you use AI?
I know for myself, using AI is a no go at this point. For me, when I do things like write this blog post, or program apps, or use ham radio equipment, I am not trying to just 'do the stuff' because I want to have the end result. For me, I am trying to learn, to increase in knowledge, skill, and ability. To keep my mind sharp. Using AI does not seem to help me do that. Perhaps it can for you. That's a decision for you to make. I'm not going to rain on your party, if you choose to use it. I know several programmers that do, and they are very sharp and are using it in a way that seems to work for them. Likewise, I have friends that create artwork with AI. That's great, for them. I don't mind that they do those things. I just can't do it myself. At least, not right now.
One last word of caution about AI that is a bit off subject: follow the money. AI is available free of charge just about everywhere for the layman. It costs money to run those machines. If they are providing that service to you for free, you might ask yourself how they are financially supporting it. Perhaps your use of it is becoming part of it's training. Or perhaps your data you put into it is becoming someone else's property. Things to consider carefully.
"Whatever your hand finds to do, do it with your might" - Ecclesiasties 9:10a
Linux - keep it simple.
[1] https://hbr.org/2026/02/ai-doesnt-reduce-work-it-intensifies-it [2] https://www.worklife.news/technology/ai-hallucinations/ [3] https://www.bbc.com/news/articles/cd6xz12j6pzo [4] https://news.harvard.edu/gazette/story/2025/11/is-ai-dulling-our-minds/

Recently I had a birthday where I was given a new Sony Playstation 5 Dualsense controller [1] (not an affiliate link). I actually don't have a Playstation, but the idea behind it was that it should work well with Ubuntu, and possibly Ubuntu Touch. This was a really cool gift, because the giver read my blog, saw what I was working on and how I commented about emulators and my lack of a controller, and made that happen! Well, I'm happy to report, not only does it work on my desktop computer, but also on Ubuntu Touch!
If you can see the above screenshot, then you can see me playing Dune, the NES version, or hack? It was made after Dune2 came out and allowed you to play a Dune2 remake on the Nintendo. Pretty cool stuff, though the controlls were a bit cumbersome, even with my awesome Playstation controller. One of the game's shortcomings is that you have to remember what you had selected last, because that will determine what the "A" button does. E.g., you thought you clicked on the light duty vehicle factory, then you click on and move some troops, and then mash the A button to build a trike, but you actually last clicked on the construction yard, and now you are going to have to figure out where to lay that 4 square yards of concrete!
Of course, the Playstation controller is Bluetooth capable, as well as having a USB-C connector so you can cable up or wirelessly connect to your computer or phone. Once I performed a pairing with my Ubuntu desktop, the controller immidiately was working for emulators that supported gamepads. No need for extra drivers or anything, which was really cool. Likewise, when I paired it with my Ubuntu Touch phone, it immidately started working.
However, it only works in Ubuntu Touch with apps that support gamepads/joysticks/controllers. For instance, my emulator I made, NesJs, does not support them, and that was a bummer. However, I downloaded the snap version of SNES9x-QT, which did support it! So, super cool! Super neat! And now I need to go figure out how to add that support to my apps.....
Linux - keep it simple.
[1] https://www.walmart.com/ip/Sony-PlayStation-5-DualSense-Wireless-Controller/188140087