jodoherty

Beautiful! Thank you for making this.

I've been trying to find something to use for enriching my own self-hosted LLMs and agentic tools with information I find useful. Metasearch tools like SearXNG make it less likely you'll get blocked by bot detection tools when finding information, but usually it's something I've already found, read, or seen that I want to incorporate into my tooling.

I came to the conclusion that a self-hosted content storage system with a search engine and a browser extension that can extract and save web page content and metadata was the ideal setup for me. Preferably with some sort of federated content sharing ability and the ability to import creative commons content like Wikipedia and Gutenberg.

This looks almost exactly like what I wanted.

It'll be a few weeks before I have time to audit the code and deploy it, but I'm really looking forward to trying it out.

Hey, thanks for the feedback!

If I get some time to circle back, I'll be sure to incorporate these into some new tests and address them.

I want to set up a qemu-system emulator based testing approach so I can incorporate things like AppArmor and SELinux into end to end tests that include different environment configurations.

Part of that will be setting up software defined networking so I can have things like DNS and wireguard VPN servers in a box and then test and evaluate the wg-wrap behavior at the packet level.

I use pi with an RTX Pro 6000 Blackwell to run Gemma 4 31b to do all my agentic coding.

I find it useful.

This side project highlights a similar approach to how I scope and tackle projects at work now:

https://git.theodohertyfamily.com/wg-wrap.git/tree/README.md

https://git.theodohertyfamily.com/wg-wrap.git/tree/CASE_STUD...

You have to apply a lot of careful architecture and TDD to your approach. Eliminate technical risk by tackling hard things early and wrapping them up in a simple, easy to use interface.

I find I can get some projects done 2-3 times faster than if I wrote them by hand. It can also save about 5-10x time on mundane or broadly scoped projects by helping me consolidate and try out ideas very quickly.

Setup-wise, I switch between vLLM using nvidia/Gemma-4-31B-IT-NVFP4 and llama.cpp using unsloth/gemma-4-31B-it-qat-GGUF with MTP. I throttle the GPU power usage to 400W.

My current llama.cpp setup gets token generation rates between 60-150 t/s depending on MTP draft acceptance rates. Prefill is between 1500-4000 t/s depending on context length/depth.

The container is a Linux container running a virtual machine inside.

WinApps needs a Windows RDP server to work. Most of the functionality doesn't care where that Windows RDP server is actually running as long as its FreeRDP client can connect to it. The container or libvirt VM options are just ways to accomplish that via virtualization.

I imagine the container part makes it easier to automate QEMU virtualization using bash scripting without worrying about distribution specific differences in the environment. These kinds of scripts become fairly ossified to their environment. Making them run consistently on different Linux distributions is its own adventure unrelated to installing and running Windows, so the containerization eliminates the need for a lot more bash scripting to account for those differences.

The container's bash scripts download the Windows installer ISOs and run them in an unattended mode inside a QEMU VM. The unattended installation is configured to skip activation:

- https://github.com/dockur/windows/blob/c7aac1edcf37a69ff730d...

- https://github.com/dockur/windows/blob/c7aac1edcf37a69ff730d...

- https://github.com/dockur/windows/blob/c7aac1edcf37a69ff730d...

Once the container is running, WinApps configures RDP via some scripts and registry settings exposed into the container via a volume so the container's scripts can copy and run them in the Windows VM:

- https://github.com/winapps-org/winapps/blob/b4766336903d0cbe...

- https://github.com/winapps-org/winapps/blob/main/oem/RDPApps...

You can do it all yourself too with your own libvirt VM, but it's just more involved:

- https://github.com/winapps-org/winapps/blob/main/docs/libvir...

I haven't seen any of this before, but I think it's a pretty clever use of scripting and containers on top of some fairly mature but hard to use pieces of software.

I worry too. American consumer credit card debt sounds like it's rising pretty quickly, and many people I talk to have a lack of free will and carry a sense of unfairness in the system they live in.

However, people can also adapt pretty quickly.

Those grocery shopping "optimization" skills are making a big come back (and have been since Covid). There are plenty of YouTube and TikTok videos popularizing how to get more out of their grocery hauls.

Lots of people are also learning how to budget, how to invest, etc. and sharing their excitement about it too. For some folks, they finally learn this stuff in their 40s and 50s, but there are also a lot of young adults learning these skills thanks to the Internet.

So I also have hope.

I just don't think the lack of basic math and budgeting skills displayed by average consumers are a problem so much as a symptom.

I think most people don't care about optimizing an extra $10 out of their weekly grocery run.

Probably a better example is figuring out the cost of a loan. Just multiply the amortized monthly payment by the term and compare that to the loan amount. If the difference makes you balk, then go ahead and walk.

How many people even realize that loan interest is a significant cost and would bother to do that? Or know how to do that? Most people just try to minimize monthly payments to something they can bear and sign the paperwork.

One of my undergrad degrees is in math. As you study it, you learn to identify your assumptions (axioms), find or build interesting abstractions, prove properties about them (theorems), and then map all sorts of other things into those abstractions by figuring out that they're really the same thing. It's even more interesting when you start to find things that are different or question things you always took for granted.

Math gives you the ability to leverage the very structure and relationships of pure abstraction. It's quite the super power.

None of the specific things you learn studying math will be nearly as useful as the ability to think mathematically.

I would hesitate to judge based on what's "easy to type" on the keyboard in front of me.

A lot of editing tools and processes automatically converting `--` to `—`, so folks editing markdown or using a Word processor might get the emdash automatically. Similar things are often done for matching double quotes. I wouldn't be surprised if quite a few WYSIWYG CMS systems do this conversion too.

There are also a lot of input methods that make it trivial to write special characters.

Apple famously uses the Alt/Option key to make inputting a lot of special characters simple. Look at any place that does a lot of writing and publishing, and you're bound to see a lot of Macs.

On Windows, you can memorize and input code points pretty easily as well if you have a number pad. Just hold Alt and punch in the 4-digit character code.

I hop platforms a lot, so I commonly use digraphs with Ctrl+K in VIM, or TeX input in Emacs to insert unicode characters. I'll also use `Ctrl+x 8 <RET>` to insert characters by name in Emacs when I need to search for something specific.

That makes sense. Mine runs every few minutes sometimes in heavy rain.

Thanks for the suggestion. It looks like 100Ah LiFePo4 batteries are pretty easy to find too.

Do you have any examples? I haven't seen what you're describing despite shopping UPSes, but something less than $100 that could last 10+ hours would be amazing.

My $200 1500VA/1000W CyperPower UPS could handle a short one or two hour storm, but storms can last for 10+ hours here during the wet season. One long power outage could cost me a lot more than $1000 in basement damages (my basement is finished).

A comparable all-in-one product to this pila battery would also be around $1000: https://us.ecoflow.com/products/delta-2-max-portable-power-s...

You can easily cut that in half shopping for an inverter and battery separately:

$240 for an inverter: https://www.homedepot.com/p/VEVOR-2500-Watt-3-4-HP-Sump-Pump...

$200 for a battery: https://www.homedepot.com/p/Basement-Watchdog-Maintenance-Fr...

But a lead acid battery might last 5 years where the pila battery is designed for 10+ years, so you're looking at $400 total on batteries. That quickly gets close to the $1000 for one pila battery.

I want to believe $100 is all you need, but to me the math with the numbers that I've seen suggests $1000 is not unreasonable for something like this.

I might get this for my basement sump pump in case the power goes out during a storm.

The official Python documentation actually comes with a Socket Programming HOWTO that goes over conceptual topics and intended socket API usage:

https://docs.python.org/dev/howto/sockets.html#socket-howto

It gets overlooked because most folks only check the Tutorial and the Standard Library sections.

The problem is platforms moved away from S3 sleep. I've heard people claim it was mostly so managed Windows laptops could force updates with the lid shut and the laptop suspended.

Now I have to worry about my laptop randomly overheating itself in my backpack and even catching fire.

The Adafruit FT232H works out of the box with pyftdi and libftdi. You don't have to use any special tools or flash it in any way. The USB commands are handled by the underlying libraries.

See page 9 of the datasheet here:

https://ftdichip.com/wp-content/uploads/2020/07/DS_FT232H.pd...

The async and sync bitbang columns denote the GPIO pins as D0-D7 and show them assigned to the 8 ADBUS pins that are provided on the breakout board.

Assuming the udev rules are set up in Linux, you can simply install pyftdi, open the device, and start using the ADBUS pins as GPIO pins:

https://eblot.github.io/pyftdi/gpio.html#setting-gpio-pin-st...

If you're using libftdi, you want to call ftdi_set_bitmode with the BITMODE_BITBANG enum value for the mode:

https://www.intra2net.com/en/developer/libftdi/documentation...

Then the ftdi_read_data and ftdi_write_data functions can be used to read or write to the ADBUS pins:

https://www.intra2net.com/en/developer/libftdi/documentation...

https://www.intra2net.com/en/developer/libftdi/documentation...

You can then build a nice, simple high level GPIO interface over that if you want.

Also, while libftdi isn't hard to work with:

http://developer.intra2net.com/git/?p=libftdi;a=blob;f=examp...

It's dead simple to also use these FTDI devices with Python:

https://eblot.github.io/pyftdi/api/index.html

FTDI also makes a lot of USB chips with software controllable GPIO pins:

https://www.adafruit.com/product/2264

https://ftdichip.com/products/ft2232h-mini-module/

Bit banging on a modern OS subjects you to a lot of jitter though. It's not like using a parallel port in DOS where you just have to worry about interrupts. The preemptive scheduler can really mess up your timing.

That said, the FT232H, FT2232H, and FT4232H have an FTDI Multi-Protocol Synchronous Serial Engine (MPSSE) cores that you can program to protocols like SPI and I2C where the high speed part doesn't require any smart logic to handle. It's a bit of a special skill though (you send MPSSE specific command bytes over the USB interface into the chip's command buffer and tell it to execute them).

If you need more high speed smarts, it's also convenient to use a Raspberry Pi Pico with MicroPython or CircuitPython with Programmable I/O (Pio) with an interactive session:

https://www.raspberrypi.com/news/what-is-pio/

https://docs.micropython.org/en/latest/rp2/quickref.html#pro...

But yeah, beyond that, you're better off using an Arduino or something and doing it all on the microcontroller.

On the plus side, all of these things are relatively cheap and easy to obtain.

Arduino is a nice, but it's still built on the shoulders of tools like GCC, isn't it?

I never owned a computer in the 90s, but my impression was that Cygnus[1] did a lot of work porting GCC and improving it for use in a variety of platforms, including embedded targets. They arguably helped pull GCC into mainstream usage, to the point of almost permanently forking it [2].

Those first 20 years of GCC development were prerequisites for something like Arduino to emerge in the mid-2000s. I'm just not sure we have the equivalent of GCC yet when it comes to synthesis tools.

When it appears, it might be a good opportunity to create a consulting company and drive it forward while also making some money. The key pitch would be improving your ability to maintain and share designs across targets while not having to pay recurring licenses on your tools.

[1] https://en.wikipedia.org/wiki/Cygnus_Solutions

[2] https://gcc.gnu.org/wiki/History

PBS Kids has a lot of games and activities on their website:

https://pbskids.org/games

If your kids watch any PBS shows them they'll recognize the characters.

The activities were fun enough for our twins to learn how to use computer mice at age 3.

Tux Paint is also really fun for young kids and a good way to learn mouse usage:

https://tuxpaint.org/

We had 3 under 3. When our son was 5 and the twins were 3, we were able to switch to forward facing car seats in the back of my Dodge Challenger, which is technically just a coupe. They're all Diono Radian car seats, and the kids fit comfortably 3 across.

Just thought I'd share in case you ever want to reconsider the dream car thing. You never know until you try and you can always bring car seats and test fit.

To your original point though, most of the time we use my wife's Honda Pilot because of the extra space for errands, sports gear, and luggage (and also because my wife doesn't want to drive stick in Northern Virginia traffic).

Cross checking work doesn't scale. That'll only become more of a problem as your business grows and you have more important concerns that pull you farther and farther away from the actual hands-on work being done.

You simply have to do it every day with self-awareness of what you're doing and why it's important until you get comfortable with it.

Day one of my first studio class, we did sketches of the person next to us and the instructor helped critique us. We learned to critique each other over time and with careful guidance.

Most normal education tends to skew towards the didactic all the way through your undergraduate studies, especially with the math and hard sciences (which includes most CS students).

That is to say, an instructor disseminates organized knowledge to the student. The student may be asked to communicate that knowledge back to prove mastery, but there's not as much emphasis on students giving each other critical feedback. Even when there is, it usually has a minor impact on your academic progress or grades.

As such, there's no incentive to learn how to give good feedback or make use of peer feedback.

Art school tends to be unique in that it cannot be taught that way. You spend years giving and receiving daily critiques and incorporating them into your growth.

The commonly accepted peer review processes we use in today's software engineering field involve giving and receiving feedback on your peers' work at a frequency that the vast majority of people simply have never experienced before.

Few people are naturally good at it, and few companies invest time into training anyone on how to do it well.

In art school, we spent a lot of time learning how to give and receive critiques, because the fastest way to improve was to try frequently and critique often.

You learn very early to divorce your ego and sense of self from your artworks and embrace every attempt as an opportunity to improve towards an ideal you can never reach.

You also learn how to give meaningful criticism without being an asshole.

Writing code is very much the same.

Unfortunately, most software engineers haven't been to art school and have no formal training in how to give and receive useful feedback.

I recommend reading Art & Fear: Observations On the Perils (and Rewards) of Artmaking. It's a good book that helps you build a healthy mindset towards growing as a creative:

https://www.amazon.com/Art-Fear-Observations-Rewards-Artmaki...

Exist.

That’s what I did for a good chunk of my twenties. My life has changed dramatically since then.

It’s hard to set a direction for yourself with that mode of living, so I pivoted from art school and joined the Air Force to focus on serving.

I’m sure the work you do can positively impact the world. Find a mission and focus on staying busy with that. Finish your PhD towards that end and continue take care of your physical health. Help people.

As a society we tend to focus on joy and pleasure as the keys to happiness (do things you like), but there’s something deeper I think you can find once you’re okay with simply existing as you feel today.

Also, the prompt is uniform and immediate anywhere you need authenticated. With a single client certificate that meets the server's criteria, most browsers can be configured to automatically apply your certificate so you never even see the prompt.

Furthermore, browsers support different kinds of storage for client certificates. You could, in theory, make a cloud hosted client certificate store that you unlock once per session to use with your browser.

Ultimately, it addresses the whole "finding the login button" concern by eliminating login flows from the application completely. If you have no certificate, then you can't access the service at a protocol level, period.

It's more like keeping your ID card with you. The hospital would still have your records but wouldn't give you access to them until you present your ID card.

If you lose your ID card, you have to go back to the issuer of ID cards and request a new one. Similarly, with client certificates, you go back to the Certificate Authority to get a new client certificate.

Mutual TLS is pretty cool. You can install client certificates into your browser issued from a CA that a server accepts, and the server can then use the details in your client certificate to authenticate you to an application specific user.

When you visit a server using mutual TLS, you'll get a prompt showing all your client certificates that match CAs that the server accepts. Once you select one, all your future requests will use that client certificate and be associated with that identity.

The client certificates can even be placed into smart card hardware devices (which can be USB or actual smart cards) that require a PIN or some other factor to use.

Because it's all built on public/private key encryption, the server has no credentials to lose in a data breach. Nobody can steal your credentials and reuse them to attack your other accounts.

And this is supported by all browsers today.

I think NixOS is what the future should be. Searching and resolving packages still seems slow, and things like flakes are still evolving to address rough edges, but having completely declarative definitions of the entire OS installation is amazing.

Spinning up native development environments as an extension of production environments is nice too.

I worry that tools like pyinfra and Ansible combined with Docker containers and traditional distributions might be good enough to prevent critical mass in terms of user adoption.

Even so, it’s worth daily driving for a while just to get a sense of what the world could be like. Kind of like Erlang OTP versus Kubernetes and containerized microservices.

I live in a region with a lot of government contracting businesses, so Red Hat Enterprise Linux is something I have to maintain a working familiarity with.

However, I use Debian for all of my personal projects and infrastructure.

The reason? There's no for-profit corporate interest directly controlling the project. The project's organizational structure resembles a constitutional democracy:

https://www.debian.org/intro/organization

There is an incorporated entity in the United States to handle a number of intellectual property and financial concerns:

https://www.spi-inc.org/projects/debian/

However, it exists as a non-profit with a very narrowly defined, specific set of purposes:

https://www.spi-inc.org/corporate/certificate-of-incorporati...

Because of this, I feel like the Debian project has a good combination of people and resources, making it easy to rely on long-term, but without the for-profit corporate interests that may conflict with my own in the future.