Full Speed Ahead

It’s been some time since I’ve been able to sit down and make an entry here, and there is a pretty simple reason for that: we have been moving full speed ahead on Dwarf Goats.

If you have been following the updates around the site, you already have some idea of how much has happened. What started as me wanting to see how far I could take ideas I have carried around for longer than I can remember has turned into something much bigger than I expected when I started.

I have to say, the results have been nothing less than astonishing.

There is so much that has happened that I’m not even sure I can get all of it into one Notebook entry, but this is probably a good place to catch everyone up on where things stand and, maybe more importantly, where I think we are going.

The first big change is the name.

Dwarf Goats will always be part of the history of this project. It is where all of this began, and I have no intention of pretending otherwise. But the project outgrew that original name.

What began on Raspberry Pi hardware has now expanded into Apple Silicon environments as well, and the operating system itself now has its permanent name:

Copper|Null.

And yes, we have a home for it now too: CopperNull.com.

That change means something to me because this is no longer just an experiment to see whether I can make an unusual operating-system idea work on a piece of hardware.

It works.

Now the question is how far we can take it.

One of the areas I have spent a tremendous amount of time on is turning Copper|Null into a system that can increasingly be used to build things from inside Copper|Null itself.

That has meant a lot of work on the native compiler and development environment: compiling, linking, running software, and steadily giving the operating system more of the tools that developers normally expect to have available to them.

That work led to another milestone I’m particularly proud of:

Python 3 now runs natively on Copper|Null.

That may sound like just another box to check, but to me it represents something much larger.

Python opens the door to rapidly building real applications directly for Copper|Null instead of treating the operating system as something that only exists to demonstrate that it can boot.

That transition—from proving the operating system works to actually building things with it—is exactly where I have wanted to get.

Then there is CopperMind.

CopperMind is the local intelligence work being developed alongside Copper|Null. The goal is not to bolt some remote cloud service onto the operating system and call it AI. The interesting part, at least to me, is exploring what happens when local intelligence becomes another native capability of the system itself.

We have already demonstrated CopperMind running within the Copper|Null environment, and more recently we have been working heavily on optimization, multi-core operation, and parallel computation.

There is still a lot of work ahead. Performance matters. Responsiveness matters. Integration matters.

But the pieces are starting to come together.

We now have an operating system that has moved across very different computing environments, has its own increasingly capable native development environment, runs Python, and can execute local AI workloads while still returning control to the person sitting at the console.

That is a long way from where this started.

The part I’m most excited about now is that more of my time can begin shifting toward applications.

One of the first is something I have been calling Eye of Hacon.

Eye of Hacon is still under development, so I’m not going to pretend it is a finished product. The idea is to explore a cleaner and more controlled way of interacting with information from the internet—something designed around what I actually want from the web rather than everything the modern web insists on throwing at me.

It is exactly the kind of application I wanted native Python on Copper|Null for.

And it will not be the last.

I want to see what kinds of tools, network applications, communication systems, games, persistent worlds, information utilities, and CopperMind-assisted software we can build when the operating system underneath them is ours to experiment with too.

That is what makes this stage of the project different.

For a long time, nearly every day was about getting one more fundamental piece of the machine to exist.

Boot.

Storage.

Networking.

A usable environment.

Development tools.

Python.

Local intelligence.

Multiple processors.

Each one opened another door.

Now enough of those doors are open that I can finally start walking through them.

There is still a tremendous amount I want to improve, and optimization is probably going to consume a fair amount of my attention for a while. But I am also deliberately starting to push development upward into actual software people can use.

I’ve spent most of my life wondering what I could build if I had enough tools, enough time, and enough freedom to follow an idea wherever it went.

Apparently the answer is:

Keep going and find out.

— Ron